From 7412384fe635441dbf5fbfff458b8d2c5b847ba7 Mon Sep 17 00:00:00 2001
From: RanVaknin <50976344+RanVaknin@users.noreply.github.com>
Date: Fri, 20 Nov 2026 11:43:41 -0800
Subject: [PATCH 1/3] Restore DynamoDBTypeConvertedJson verbatim
Restore @DynamoDBTypeConvertedJson and its tests exactly as they were
at f8d9c8c3c4a, before #7502 removed them, so the next commit shows
only the changes needed to drop the jackson-databind dependency.
This commit does not compile on its own: the annotation still imports
jackson-databind, which the mapper no longer depends on.
---
.../dynamodb/DynamoDBTypeConvertedJson.java | 103 ++++++++
.../LegacyMarshallerMigrationTest.java | 154 +++++++++++-
.../StandardModelFactoriesEdgeCasesTest.java | 57 ++++-
...rtedJsonMultiAttributeIntegrationTest.java | 221 ++++++++++++++++++
.../TypeConvertedJsonIntegrationTest.java | 96 ++++++++
.../mapper/TypeConvertedJsonTest.java | 101 ++++++++
.../pojos/AllSupportedAnnotationsClass.java | 14 +-
7 files changed, 743 insertions(+), 3 deletions(-)
create mode 100644 services-custom/dynamodb-mapper/src/main/java/software/amazon/awssdk/mapper/dynamodb/DynamoDBTypeConvertedJson.java
create mode 100644 services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/TypeConvertedJsonMultiAttributeIntegrationTest.java
create mode 100644 services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/mapper/TypeConvertedJsonIntegrationTest.java
create mode 100644 services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/mapper/TypeConvertedJsonTest.java
diff --git a/services-custom/dynamodb-mapper/src/main/java/software/amazon/awssdk/mapper/dynamodb/DynamoDBTypeConvertedJson.java b/services-custom/dynamodb-mapper/src/main/java/software/amazon/awssdk/mapper/dynamodb/DynamoDBTypeConvertedJson.java
new file mode 100644
index 000000000000..3a398e96bf2f
--- /dev/null
+++ b/services-custom/dynamodb-mapper/src/main/java/software/amazon/awssdk/mapper/dynamodb/DynamoDBTypeConvertedJson.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ * http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file 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 software.amazon.awssdk.mapper.dynamodb;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.ObjectWriter;
+import software.amazon.awssdk.annotations.SdkPreviewApi;
+
+/**
+ * A simple JSON converter that uses the Jackson JSON processor.
+ *
+ *
It shares all limitations of that library. For more information about
+ * Jackson, see: http://wiki.fasterxml.com/JacksonHome
+ *
+ * @see software.amazon.awssdk.mapper.dynamodb.DynamoDBTypeConverted
+ */
+@SdkPreviewApi
+@DynamoDBTypeConverted(converter=DynamoDBTypeConvertedJson.Converter.class)
+@DynamoDBTyped(DynamoDBMapperFieldModel.DynamoDBAttributeType.S)
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD})
+public @interface DynamoDBTypeConvertedJson {
+
+ /**
+ * The value type to use when calling the JSON mapper's {@code readValue};
+ * a value of {@code Void.class} indicates to use the getter's type.
+ */
+ Class extends Object> targetType() default void.class;
+
+ /**
+ * JSON type converter.
+ */
+ final class Converter implements DynamoDBTypeConverter {
+ private static final ObjectMapper mapper = new ObjectMapper().disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
+ private final Class targetType;
+
+ public Converter(Class targetType, DynamoDBTypeConvertedJson annotation) {
+ this.targetType = annotation.targetType() == void.class ? targetType : (Class)annotation.targetType();
+ }
+
+ @Override
+ public final String convert(final T object) {
+ try {
+ return mapper.writeValueAsString(object);
+ } catch (final Exception e) {
+ throw new DynamoDBMappingException("Unable to write object to JSON", e);
+ }
+ }
+
+ @Override
+ public final T unconvert(final String object) {
+ try {
+ return mapper.readValue(object, targetType);
+ } catch (final Exception e) {
+ throw new DynamoDBMappingException("Unable to read JSON string", e);
+ }
+ }
+ }
+
+}
diff --git a/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/LegacyMarshallerMigrationTest.java b/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/LegacyMarshallerMigrationTest.java
index d88a434d23b5..70269e6995dc 100644
--- a/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/LegacyMarshallerMigrationTest.java
+++ b/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/LegacyMarshallerMigrationTest.java
@@ -18,7 +18,11 @@
import static org.junit.Assert.assertEquals;
import com.amazonaws.services.dynamodbv2.datamodeling.AbstractEnumMarshaller;
+import com.amazonaws.services.dynamodbv2.datamodeling.JsonMarshaller;
+import java.util.ArrayList;
+import java.util.Date;
import java.util.HashMap;
+import java.util.List;
import java.util.Map;
import java.util.UUID;
import org.junit.After;
@@ -34,7 +38,7 @@
/**
* Verifies the migration path from the removed v1 marshaller layer ({@code DynamoDBMarshaller},
- * {@code @DynamoDBMarshalling}, {@code AbstractEnumMarshaller}) to the converter layer.
+ * {@code @DynamoDBMarshalling}, {@code AbstractEnumMarshaller}, {@code JsonMarshaller}) to the converter layer.
*
* Fixtures are produced by the real v1 marshallers ({@code com.amazonaws.services.dynamodbv2.datamodeling}), so the
* tests check that items written by v1 load unchanged through the replacement annotations, and that items written
@@ -47,7 +51,12 @@ public class LegacyMarshallerMigrationTest extends LocalDynamoDBTestBase {
private static final String TABLE_NAME =
LegacyMarshallerMigrationTest.class.getSimpleName() + "-" + System.currentTimeMillis();
+ // A fixed instant with non-zero milliseconds, to catch any precision loss in the JSON date encoding.
+ private static final Date UPDATED = new Date(1_700_000_000_123L);
+
private static final AbstractEnumMarshaller V1_ENUM = new AbstractEnumMarshaller() { };
+ private static final JsonMarshaller V1_PART_JSON = new JsonMarshaller(Part.class);
+ private static final JsonMarshaller V1_PART_LIST_JSON = new JsonMarshaller(PartList.class);
private DynamoDbClient ddb;
private DynamoDBMapper mapper;
@@ -109,6 +118,83 @@ public void genericConverterWithClassConstructor_readsV1EnumMarshallerOutput() {
assertEquals(Status.X, mapper.load(Item.class, key).getGenericStatus());
}
+ @Test
+ public void typeConvertedJson_readsV1JsonMarshallerOutput() {
+ PartList parts = new PartList();
+ parts.add(new Part("b", 1, UPDATED));
+ parts.add(new Part("c", 2, null));
+ Map item = new HashMap();
+ item.put("part", s(V1_PART_JSON.marshall(new Part("a", 3, UPDATED))));
+ item.put("parts", s(V1_PART_LIST_JSON.marshall(parts)));
+ String key = putRaw(item);
+
+ Item loaded = mapper.load(Item.class, key);
+
+ assertPart(loaded.getPart(), "a", 3, UPDATED);
+ assertEquals(PartList.class, loaded.getParts().getClass());
+ assertEquals(2, loaded.getParts().size());
+ assertPart(loaded.getParts().get(0), "b", 1, UPDATED);
+ assertPart(loaded.getParts().get(1), "c", 2, null);
+ }
+
+ @Test
+ public void typeConvertedJson_writesFormatV1JsonMarshallerReads() {
+ Item item = newItem();
+ item.setPart(new Part("a", 3, UPDATED));
+ List parts = new ArrayList();
+ parts.add(new Part("b", 1, UPDATED));
+ item.setParts(parts);
+ mapper.save(item);
+
+ Map stored = getRaw(item.getKey());
+
+ // Byte-for-byte the same JSON the legacy JsonMarshaller writes, not just readable by it.
+ assertEquals(V1_PART_JSON.marshall(item.getPart()), stored.get("part").s());
+ PartList expectedParts = new PartList();
+ expectedParts.addAll(parts);
+ assertEquals(V1_PART_LIST_JSON.marshall(expectedParts), stored.get("parts").s());
+
+ assertPart(V1_PART_JSON.unmarshall(Part.class, stored.get("part").s()), "a", 3, UPDATED);
+ PartList v1Parts = V1_PART_LIST_JSON.unmarshall(PartList.class, stored.get("parts").s());
+ assertEquals(1, v1Parts.size());
+ assertPart(v1Parts.get(0), "b", 1, UPDATED);
+ }
+
+ /**
+ * Unlike the legacy {@code JsonMarshaller}, the replacement ignores JSON properties the class does not declare,
+ * for example ones added by a newer writer.
+ */
+ @Test
+ public void typeConvertedJson_withUnknownProperty_ignoresIt() {
+ String legacy = V1_PART_JSON.marshall(new Part("a", 3, UPDATED));
+ String withExtra = legacy.substring(0, legacy.length() - 1) + ",\"addedLater\":\"x\"}";
+ String key = putRaw("part", s(withExtra));
+
+ assertPart(mapper.load(Item.class, key).getPart(), "a", 3, UPDATED);
+ }
+
+ @Test
+ public void typeConvertedJson_roundTrips() {
+ Item item = newItem();
+ item.setPart(new Part("a", 3, UPDATED));
+ List parts = new ArrayList();
+ parts.add(new Part("b", 1, null));
+ item.setParts(parts);
+
+ mapper.save(item);
+ Item loaded = mapper.load(Item.class, item.getKey());
+
+ assertPart(loaded.getPart(), "a", 3, UPDATED);
+ assertEquals(1, loaded.getParts().size());
+ assertPart(loaded.getParts().get(0), "b", 1, null);
+ }
+
+ private static void assertPart(Part part, String id, int quantity, Date updated) {
+ assertEquals(id, part.getId());
+ assertEquals(Integer.valueOf(quantity), part.getQuantity());
+ assertEquals(updated, part.getUpdated());
+ }
+
private static AttributeValue s(String value) {
return AttributeValue.builder().s(value).build();
}
@@ -163,11 +249,59 @@ public E unconvert(String object) {
}
}
+ /**
+ * Concrete list type that keeps the element type through erasure, as a legacy {@code JsonMarshaller} subclass
+ * would have with {@code super(Type.class)}.
+ */
+ public static final class PartList extends ArrayList {
+ }
+
+ public static class Part {
+ private String id;
+ private Integer quantity;
+ private Date updated;
+
+ public Part() {
+ }
+
+ public Part(String id, Integer quantity, Date updated) {
+ this.id = id;
+ this.quantity = quantity;
+ this.updated = updated;
+ }
+
+ public String getId() {
+ return id;
+ }
+
+ public void setId(String id) {
+ this.id = id;
+ }
+
+ public Integer getQuantity() {
+ return quantity;
+ }
+
+ public void setQuantity(Integer quantity) {
+ this.quantity = quantity;
+ }
+
+ public Date getUpdated() {
+ return updated;
+ }
+
+ public void setUpdated(Date updated) {
+ this.updated = updated;
+ }
+ }
+
@DynamoDBTable(tableName = "overridden")
public static class Item {
private String key;
private Status status;
private Status genericStatus;
+ private Part part;
+ private List parts;
@DynamoDBHashKey
public String getKey() {
@@ -195,5 +329,23 @@ public Status getGenericStatus() {
public void setGenericStatus(Status genericStatus) {
this.genericStatus = genericStatus;
}
+
+ @DynamoDBTypeConvertedJson
+ public Part getPart() {
+ return part;
+ }
+
+ public void setPart(Part part) {
+ this.part = part;
+ }
+
+ @DynamoDBTypeConvertedJson(targetType = PartList.class)
+ public List getParts() {
+ return parts;
+ }
+
+ public void setParts(List parts) {
+ this.parts = parts;
+ }
}
}
diff --git a/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/StandardModelFactoriesEdgeCasesTest.java b/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/StandardModelFactoriesEdgeCasesTest.java
index 3312e9b15859..77358daaba3c 100644
--- a/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/StandardModelFactoriesEdgeCasesTest.java
+++ b/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/StandardModelFactoriesEdgeCasesTest.java
@@ -48,7 +48,7 @@ public class StandardModelFactoriesEdgeCasesTest {
.withConversionSchema(ConversionSchemas.V2)
.build();
- private static final DynamoDBMapperModelFactory factory = StandardModelFactories.of();
+ private static final DynamoDBMapperModelFactory factory = StandardModelFactories.of(S3Link.Factory.of(null));
private static final DynamoDBMapperModelFactory.TableFactory v1Models = factory.getTableFactory(V1_CONFIG);
private static final DynamoDBMapperModelFactory.TableFactory v2Models = factory.getTableFactory(V2_CONFIG);
@@ -169,6 +169,61 @@ public void unconvert_withUnknownEnumValue_throwsException() {
}
}
+ public static class JsonPayload {
+ private String name;
+ private int count;
+ public String getName() { return name; }
+ public void setName(String name) { this.name = name; }
+ public int getCount() { return count; }
+ public void setCount(int count) { this.count = count; }
+ @Override
+ public boolean equals(Object o) {
+ if (!(o instanceof JsonPayload)) {
+ return false;
+ }
+ JsonPayload that = (JsonPayload) o;
+ return count == that.count
+ && (name == null ? that.name == null : name.equals(that.name));
+ }
+ @Override
+ public int hashCode() {
+ return (name == null ? 0 : name.hashCode()) * 31 + count;
+ }
+ }
+
+ public static class JsonPojo extends AutoKeyAndVal {
+ @DynamoDBTypeConvertedJson
+ public JsonPayload getVal() { return super.getVal(); }
+ public void setVal(JsonPayload val) { super.setVal(val); }
+ }
+
+ @Test
+ public void convert_withJsonPayload_producesString() {
+ JsonPayload payload = new JsonPayload();
+ payload.setName("widget");
+ payload.setCount(7);
+
+ DynamoDBMapperTableModel model = table(new JsonPojo());
+ AttributeValue av = model.field("val").convert(payload);
+
+ Assert.assertNotNull(av.s());
+ Assert.assertTrue(av.s().contains("widget"));
+ Assert.assertTrue(av.s().contains("7"));
+ }
+
+ @Test
+ public void convertAndUnconvert_withJsonPayload_roundTrips() {
+ JsonPayload payload = new JsonPayload();
+ payload.setName("widget");
+ payload.setCount(7);
+
+ DynamoDBMapperTableModel model = table(new JsonPojo());
+ AttributeValue av = model.field("val").convert(payload);
+ Object back = model.field("val").unconvert(av);
+
+ assertEquals(payload, back);
+ }
+
@Test
public void unconvert_withByteBuffer_returnsWritableBuffer() {
// v1 parity: v1 getB() returned a writable buffer. v2 SdkBytes.asByteBuffer() is
diff --git a/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/TypeConvertedJsonMultiAttributeIntegrationTest.java b/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/TypeConvertedJsonMultiAttributeIntegrationTest.java
new file mode 100644
index 000000000000..48275e2da636
--- /dev/null
+++ b/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/TypeConvertedJsonMultiAttributeIntegrationTest.java
@@ -0,0 +1,221 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ * http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file 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 software.amazon.awssdk.mapper.dynamodb;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.UUID;
+
+import org.junit.Test;
+
+import software.amazon.awssdk.mapper.dynamodb.DynamoDBMapperIntegrationTestBase;
+import software.amazon.awssdk.mapper.dynamodb.DynamoDBAutoGeneratedKey;
+import software.amazon.awssdk.mapper.dynamodb.DynamoDBHashKey;
+import software.amazon.awssdk.mapper.dynamodb.DynamoDBTable;
+import software.amazon.awssdk.mapper.dynamodb.DynamoDBTypeConvertedJson;
+
+/**
+ * Integration tests for an item with several {@code @DynamoDBTypeConvertedJson} attributes, including lists
+ * bound to a concrete element type through {@code targetType}. This is the replacement for the removed v1
+ * {@code JsonMarshaller} / {@code @DynamoDBMarshalling} pair.
+ */
+public class TypeConvertedJsonMultiAttributeIntegrationTest extends DynamoDBMapperIntegrationTestBase {
+
+ @Test
+ public void testMarshalling() {
+ final DynamoDBMapper mapper = new DynamoDBMapper(dynamo);
+
+ final TestObject object1 = new TestObject();
+ object1.setOneItem(new TestObject.OneItem());
+ object1.addOneItem(new TestObject.OneItem(UUID.randomUUID().toString(), 1));
+ object1.addOneItem(new TestObject.OneItem(UUID.randomUUID().toString(), 2));
+ object1.addOneItem(new TestObject.OneItem(UUID.randomUUID().toString(), 3));
+ object1.setTwoItem(new TestObject.TwoItem());
+ object1.addTwoItem(new TestObject.TwoItem(UUID.randomUUID().toString(), new Date()));
+
+ mapper.save(object1);
+
+ assertNotNull(object1.getKey());
+
+ assertNotNull(object1.getOneItem());
+ assertNotNull(object1.getOneItems());
+ assertEquals(3, object1.getOneItems().size());
+
+ assertNotNull(object1.getTwoItem());
+ assertNotNull(object1.getTwoItems());
+ assertEquals(1, object1.getTwoItems().size());
+
+ final TestObject object2 = mapper.load(TestObject.class, object1.getKey());
+
+ assertEquals(object1.getKey(), object2.getKey());
+
+ assertEquals(object1.getOneItem().getId(), object2.getOneItem().getId());
+ assertEquals(object1.getOneItem().getQuantity(), object2.getOneItem().getQuantity());
+ assertEquals(object1.getOneItems().size(), object2.getOneItems().size());
+
+ for (int i = 0, its = object1.getOneItems().size(); i < its; i++) {
+ assertEquals(object1.getOneItems().get(i).getId(), object2.getOneItems().get(i).getId());
+ assertEquals(object1.getOneItems().get(i).getQuantity(), object2.getOneItems().get(i).getQuantity());
+ }
+
+ assertEquals(object1.getTwoItem().getId(), object2.getTwoItem().getId());
+ assertEquals(object1.getTwoItem().getDate(), object2.getTwoItem().getDate());
+ assertEquals(object1.getTwoItems().size(), object2.getTwoItems().size());
+
+ for (int i = 0, its = object1.getTwoItems().size(); i < its; i++) {
+ assertEquals(object1.getTwoItems().get(i).getId(), object2.getTwoItems().get(i).getId());
+ assertEquals(object1.getTwoItems().get(i).getDate(), object2.getTwoItems().get(i).getDate());
+ }
+ }
+
+ @DynamoDBTable(tableName="aws-java-sdk-util")
+ public static class TestObject {
+ // Concrete list types keep the element type through erasure, as the legacy JsonMarshaller subclasses did.
+ public static final class OneItemList extends ArrayList { }
+ public static final class TwoItemList extends ArrayList { }
+
+ private String key;
+ private OneItem aitem;
+ private List oneItems;
+ private TwoItem bitem;
+ private List twoItems;
+
+ @DynamoDBHashKey
+ @DynamoDBAutoGeneratedKey
+ public String getKey() {
+ return this.key;
+ }
+
+ public void setKey(String key) {
+ this.key = key;
+ }
+
+ @DynamoDBTypeConvertedJson
+ public OneItem getOneItem() {
+ return this.aitem;
+ }
+
+ public void setOneItem(OneItem aitem) {
+ this.aitem = aitem;
+ }
+
+ @DynamoDBTypeConvertedJson(targetType = OneItemList.class)
+ public List getOneItems() {
+ return this.oneItems;
+ }
+
+ public void setOneItems(List oneItems) {
+ this.oneItems = oneItems;
+ }
+
+ public void addOneItem(OneItem aitem) {
+ if (this.oneItems == null) {
+ this.oneItems = new ArrayList();
+ }
+ this.oneItems.add(aitem);
+ }
+
+ @DynamoDBTypeConvertedJson
+ public TwoItem getTwoItem() {
+ return this.bitem;
+ }
+
+ public void setTwoItem(TwoItem bitem) {
+ this.bitem = bitem;
+ }
+
+ @DynamoDBTypeConvertedJson(targetType = TwoItemList.class)
+ public List getTwoItems() {
+ return this.twoItems;
+ }
+
+ public void setTwoItems(List twoItems) {
+ this.twoItems = twoItems;
+ }
+
+ public void addTwoItem(TwoItem bitem) {
+ if (this.twoItems == null) {
+ this.twoItems = new ArrayList();
+ }
+ this.twoItems.add(bitem);
+ }
+
+ public static class OneItem {
+ private String id;
+ private Integer quantity;
+
+ public OneItem(String id, Integer quantity) {
+ this.id = id;
+ this.quantity = quantity;
+ }
+
+ public OneItem() {
+ this(null, null);
+ }
+
+ public String getId() {
+ return this.id;
+ }
+
+ public void setId(String id) {
+ this.id = id;
+ }
+
+ public Integer getQuantity() {
+ return this.quantity;
+ }
+
+ public void setQuantity(Integer quantity) {
+ this.quantity = quantity;
+ }
+ }
+
+ public static class TwoItem {
+ private String id;
+ private Date date;
+
+ public TwoItem(String id, Date date) {
+ this.id = id;
+ this.date = date;
+ }
+
+ public TwoItem() {
+ this(null, null);
+ }
+
+ public String getId() {
+ return this.id;
+ }
+
+ public void setId(String id) {
+ this.id = id;
+ }
+
+ public Date getDate() {
+ return this.date;
+ }
+
+ public void setDate(Date date) {
+ this.date = date;
+ }
+ }
+ }
+}
diff --git a/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/mapper/TypeConvertedJsonIntegrationTest.java b/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/mapper/TypeConvertedJsonIntegrationTest.java
new file mode 100644
index 000000000000..2c10edc8eebf
--- /dev/null
+++ b/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/mapper/TypeConvertedJsonIntegrationTest.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ * http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file 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 software.amazon.awssdk.mapper.dynamodb.mapper;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import software.amazon.awssdk.mapper.dynamodb.DynamoDBAutoGeneratedKey;
+import software.amazon.awssdk.mapper.dynamodb.DynamoDBHashKey;
+import software.amazon.awssdk.mapper.dynamodb.DynamoDBTable;
+import software.amazon.awssdk.mapper.dynamodb.DynamoDBTypeConvertedJson;
+import software.amazon.awssdk.mapper.dynamodb.pojos.AutoKeyAndVal;
+import software.amazon.awssdk.mapper.dynamodb.pojos.Currency;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Test;
+
+/**
+ * Integration tests for {@code DynamoDBTypeConvertedJson}.
+ */
+public class TypeConvertedJsonIntegrationTest extends AbstractKeyAndValIntegrationTestCase {
+
+ /**
+ * Test marshalling.
+ */
+ @Test
+ public void testMarshalling() {
+ final KeyAndCurrency object = new KeyAndCurrency();
+ object.setVal(new Currency(12.95D, "USD"));
+ assertBeforeAndAfterChange(false, object);
+ }
+
+ /**
+ * Test marshalling a list.
+ */
+ @Test
+ public void testListMarshalling() {
+ final KeyAndCurrencyList object = new KeyAndCurrencyList();
+ object.setVal(new ArrayList());
+ object.getVal().add(new Currency(1.99D, "CAD"));
+ object.getVal().add(new Currency(2.99D, "CAD"));
+
+ final List after = assertBeforeAndAfterChange(false, object);
+ for (final Currency currency : after) {
+ assertNotNull(currency.getAmount());
+ assertNotNull(currency.getUnit());
+ }
+ }
+
+ /**
+ * An object with a complex type.
+ */
+ @DynamoDBTable(tableName="aws-java-sdk-util")
+ public static class KeyAndCurrency extends AutoKeyAndVal {
+ @DynamoDBTypeConvertedJson
+ public Currency getVal() {
+ return super.getVal();
+ }
+ @Override
+ public void setVal(final Currency val) {
+ super.setVal(val);
+ }
+ }
+
+ /**
+ * An object with a complex type.
+ */
+ @DynamoDBTable(tableName="aws-java-sdk-util")
+ public static class KeyAndCurrencyList extends AutoKeyAndVal> {
+ public static final class CurrencyListType extends ArrayList {}
+ @DynamoDBTypeConvertedJson(targetType=CurrencyListType.class)
+ public List getVal() {
+ return super.getVal();
+ }
+ @Override
+ public void setVal(final List val) {
+ super.setVal(val);
+ }
+ }
+
+}
diff --git a/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/mapper/TypeConvertedJsonTest.java b/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/mapper/TypeConvertedJsonTest.java
new file mode 100644
index 000000000000..4ab5df46f7ae
--- /dev/null
+++ b/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/mapper/TypeConvertedJsonTest.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ * http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file 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 software.amazon.awssdk.mapper.dynamodb.mapper;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
+import software.amazon.awssdk.mapper.dynamodb.DynamoDBHashKey;
+import software.amazon.awssdk.mapper.dynamodb.DynamoDBMapper;
+import software.amazon.awssdk.mapper.dynamodb.DynamoDBTable;
+import software.amazon.awssdk.mapper.dynamodb.DynamoDBTypeConvertedJson;
+import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
+import software.amazon.awssdk.services.dynamodb.model.GetItemRequest;
+import software.amazon.awssdk.services.dynamodb.model.GetItemResponse;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class TypeConvertedJsonTest {
+
+ private static final String HASH_KEY = "1234";
+
+ @Mock
+ private DynamoDbClient ddb;
+
+ @Test
+ public void responseWithUnmappedField_IgnoresUnknownFieldAndUnmarshallsCorrectly() {
+ final DynamoDBMapper mapper = new DynamoDBMapper(ddb);
+ Map item = new HashMap<>();
+ item.put("hashKey", AttributeValue.builder().s(HASH_KEY).build());
+ item.put("jsonMappedPojo", AttributeValue.builder().s(
+ "{\"knownField\": \"knownValue\", \"unknownField\": \"unknownValue\"}").build());
+ when(ddb.getItem(any(GetItemRequest.class)))
+ .thenReturn(GetItemResponse.builder().item(item).build());
+
+ final TopLevelPojo pojo = mapper.load(new TopLevelPojo().setHashKey(HASH_KEY));
+ assertEquals("knownValue", pojo.getJsonMappedPojo().getKnownField());
+ }
+
+ @DynamoDBTable(tableName = "TestTable")
+ public static class TopLevelPojo {
+
+ @DynamoDBHashKey
+ private String hashKey;
+
+ @DynamoDBTypeConvertedJson
+ private JsonMappedPojo jsonMappedPojo;
+
+ public String getHashKey() {
+ return hashKey;
+ }
+
+ public TopLevelPojo setHashKey(String hashKey) {
+ this.hashKey = hashKey;
+ return this;
+ }
+
+ public JsonMappedPojo getJsonMappedPojo() {
+ return jsonMappedPojo;
+ }
+
+ public void setJsonMappedPojo(JsonMappedPojo jsonMappedPojo) {
+ this.jsonMappedPojo = jsonMappedPojo;
+ }
+ }
+
+ public static class JsonMappedPojo {
+
+ private String knownField;
+
+ public String getKnownField() {
+ return knownField;
+ }
+
+ public void setKnownField(String knownField) {
+ this.knownField = knownField;
+ }
+ }
+
+}
diff --git a/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/pojos/AllSupportedAnnotationsClass.java b/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/pojos/AllSupportedAnnotationsClass.java
index eb28beb369c3..1b9c36712d33 100644
--- a/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/pojos/AllSupportedAnnotationsClass.java
+++ b/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/pojos/AllSupportedAnnotationsClass.java
@@ -29,6 +29,7 @@
import software.amazon.awssdk.mapper.dynamodb.DynamoDBKeyed;
import software.amazon.awssdk.mapper.dynamodb.DynamoDBNamed;
import software.amazon.awssdk.mapper.dynamodb.DynamoDBTable;
+import software.amazon.awssdk.mapper.dynamodb.DynamoDBTypeConvertedJson;
import software.amazon.awssdk.mapper.dynamodb.DynamoDBTypeConvertedEpochDate;
import software.amazon.awssdk.services.dynamodb.model.KeyType;
@@ -52,6 +53,7 @@ public class AllSupportedAnnotationsClass extends TestDocClass {
private String gsiHashKey;
private String gsiRangeKey;
private String namedAttribute;
+ private Currency currencyAttribute;
private Date epochDate;
private DateRange dateRange;
@@ -154,6 +156,15 @@ public void setNamedAttribute(String namedAttribute) {
this.namedAttribute = namedAttribute;
}
+ @DynamoDBTypeConvertedJson
+ public Currency getCurrencyAttribute() {
+ return currencyAttribute;
+ }
+
+ public void setCurrencyAttribute(Currency currencyAttribute) {
+ this.currencyAttribute = currencyAttribute;
+ }
+
@DynamoDBTypeConvertedEpochDate
public Date getEpochDate() {
return epochDate;
@@ -189,6 +200,7 @@ && eq(ignoredAttribute, other.ignoredAttribute)
&& eq(gsiHashKey, other.gsiHashKey)
&& eq(gsiRangeKey, other.gsiRangeKey)
&& eq(namedAttribute, other.namedAttribute)
+ && eq(currencyAttribute, other.currencyAttribute)
&& eq(epochDate, other.epochDate)
&& eq(dateRange, other.dateRange)
&& super.equals(other)
@@ -201,7 +213,7 @@ public String toString() {
+ ", mapOfLists=" + super.getMapOfLists() + ", integerAttribute=" + integerAttribute + ", uuid=" + uuid + ", date=" + date
+ ", defaultAttribute=" + defaultAttribute + ", booleanAttribute=" + booleanAttribute + ", phoneNumber=" + phoneNumber
+ ", ignoredAttribute=" + ignoredAttribute + ", gsiHashKey=" + gsiHashKey + ", gsiRangeKey=" + gsiRangeKey
- + ", namedAttribute=" + namedAttribute + ", epochDate=" + epochDate +", dateRange=" + dateRange
+ + ", namedAttribute=" + namedAttribute + ", currencyAttribute=" + currencyAttribute + ", epochDate=" + epochDate +", dateRange=" + dateRange
+ "}";
}
}
From 354df240904fe1d60d5ed4c2c3c048c627044b95 Mon Sep 17 00:00:00 2001
From: RanVaknin <50976344+RanVaknin@users.noreply.github.com>
Date: Fri, 20 Nov 2026 14:04:03 -0800
Subject: [PATCH 2/3] Use the application's jackson-databind
Call jackson-databind through reflection instead of depending on it, so
the mapper ships without databind and @DynamoDBTypeConvertedJson uses
the application's copy. The calls and configuration match the v1
converter exactly, so stored JSON stays the same.
When databind is missing, the mapper throws a DynamoDBMappingException
naming the dependency to add, when it builds the model for an annotated
class.
Add tests against v1's own converter, a test run with databind removed
from the classpath, and databind as a test-only dependency.
---
services-custom/dynamodb-mapper/pom.xml | 30 +++
.../dynamodb/DynamoDBTypeConvertedJson.java | 13 +-
.../dynamodb/JacksonDatabindSupport.java | 161 +++++++++++++++
...amoDBMapperWithoutJacksonDatabindTest.java | 146 ++++++++++++++
.../DynamoDBTypeConvertedJsonTest.java | 187 ++++++++++++++++++
.../StandardModelFactoriesEdgeCasesTest.java | 2 +-
6 files changed, 532 insertions(+), 7 deletions(-)
create mode 100644 services-custom/dynamodb-mapper/src/main/java/software/amazon/awssdk/mapper/dynamodb/JacksonDatabindSupport.java
create mode 100644 services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/DynamoDBMapperWithoutJacksonDatabindTest.java
create mode 100644 services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/DynamoDBTypeConvertedJsonTest.java
diff --git a/services-custom/dynamodb-mapper/pom.xml b/services-custom/dynamodb-mapper/pom.xml
index 40e82fdaca84..73f465cd6a5d 100644
--- a/services-custom/dynamodb-mapper/pom.xml
+++ b/services-custom/dynamodb-mapper/pom.xml
@@ -91,6 +91,7 @@
**/*WithoutJodaTimeTest.java
+ **/*WithoutJacksonDatabindTest.java
@@ -116,6 +117,28 @@
+
+
+ without-jackson-databind
+
+ test
+
+
+
+ **/*WithoutJacksonDatabindTest.java
+
+
+ *WithoutJacksonDatabindTest
+
+ com.fasterxml.jackson.core:jackson-databind
+
+
+ true
+
+
+
@@ -179,6 +202,13 @@
+
+
+ com.fasterxml.jackson.core
+ jackson-databind
+ test
+ junitjunit
diff --git a/services-custom/dynamodb-mapper/src/main/java/software/amazon/awssdk/mapper/dynamodb/DynamoDBTypeConvertedJson.java b/services-custom/dynamodb-mapper/src/main/java/software/amazon/awssdk/mapper/dynamodb/DynamoDBTypeConvertedJson.java
index 3a398e96bf2f..42fe345d56be 100644
--- a/services-custom/dynamodb-mapper/src/main/java/software/amazon/awssdk/mapper/dynamodb/DynamoDBTypeConvertedJson.java
+++ b/services-custom/dynamodb-mapper/src/main/java/software/amazon/awssdk/mapper/dynamodb/DynamoDBTypeConvertedJson.java
@@ -20,9 +20,6 @@
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
-import com.fasterxml.jackson.databind.DeserializationFeature;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.ObjectWriter;
import software.amazon.awssdk.annotations.SdkPreviewApi;
/**
@@ -31,6 +28,10 @@
*
It shares all limitations of that library. For more information about
* Jackson, see: http://wiki.fasterxml.com/JacksonHome
*
+ *
jackson-databind is not a dependency of the mapper. Applications that use this annotation must add
+ * {@code com.fasterxml.jackson.core:jackson-databind} 2.x to their classpath. Without it, the mapper throws a
+ * {@link DynamoDBMappingException} when it builds the model for a class that uses this annotation.
+ *
* {@snippet :
* @DynamoDBTypeConvertedJson
* public Currency getCurrency() { return currency; }
@@ -74,17 +75,17 @@
* JSON type converter.
*/
final class Converter implements DynamoDBTypeConverter {
- private static final ObjectMapper mapper = new ObjectMapper().disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
private final Class targetType;
public Converter(Class targetType, DynamoDBTypeConvertedJson annotation) {
this.targetType = annotation.targetType() == void.class ? targetType : (Class)annotation.targetType();
+ JacksonDatabindSupport.initialize();
}
@Override
public final String convert(final T object) {
try {
- return mapper.writeValueAsString(object);
+ return JacksonDatabindSupport.writeValueAsString(object);
} catch (final Exception e) {
throw new DynamoDBMappingException("Unable to write object to JSON", e);
}
@@ -93,7 +94,7 @@ public final String convert(final T object) {
@Override
public final T unconvert(final String object) {
try {
- return mapper.readValue(object, targetType);
+ return JacksonDatabindSupport.readValue(object, targetType);
} catch (final Exception e) {
throw new DynamoDBMappingException("Unable to read JSON string", e);
}
diff --git a/services-custom/dynamodb-mapper/src/main/java/software/amazon/awssdk/mapper/dynamodb/JacksonDatabindSupport.java b/services-custom/dynamodb-mapper/src/main/java/software/amazon/awssdk/mapper/dynamodb/JacksonDatabindSupport.java
new file mode 100644
index 000000000000..43eb1ff39ad0
--- /dev/null
+++ b/services-custom/dynamodb-mapper/src/main/java/software/amazon/awssdk/mapper/dynamodb/JacksonDatabindSupport.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ * http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file 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 software.amazon.awssdk.mapper.dynamodb;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import software.amazon.awssdk.annotations.SdkInternalApi;
+import software.amazon.awssdk.utils.Lazy;
+
+/**
+ * Calls the application's jackson-databind for {@link DynamoDBTypeConvertedJson}. The mapper doesn't depend on
+ * jackson-databind, so this class finds it on the classpath by name and calls it through reflection.
+ *
+ *
The calls and configuration match the v1 mapper's converter exactly, so the stored JSON is the same: one shared
+ * {@code ObjectMapper} with {@code FAIL_ON_UNKNOWN_PROPERTIES} disabled, {@code writeValueAsString(Object)} to write
+ * and {@code readValue(String, Class)} to read.
+ *
+ *
This class must not reference any jackson-databind type, so that it can be loaded without jackson-databind.
+ */
+@SdkInternalApi
+final class JacksonDatabindSupport {
+
+ private static final String OBJECT_MAPPER_CLASS = "com.fasterxml.jackson.databind.ObjectMapper";
+ private static final String DESERIALIZATION_FEATURE_CLASS = "com.fasterxml.jackson.databind.DeserializationFeature";
+
+ /**
+ * Checked with the mapper's own class loader, for the same reason as {@link JodaTimeSupport}.
+ */
+ private static final boolean AVAILABLE = isLoadable(OBJECT_MAPPER_CLASS);
+
+ private static final Lazy BRIDGE = new Lazy<>(ObjectMapperBridge::create);
+
+ private JacksonDatabindSupport() {
+ }
+
+ /**
+ * Returns whether jackson-databind is on the mapper's classpath.
+ */
+ static boolean isAvailable() {
+ return AVAILABLE;
+ }
+
+ /**
+ * Returns the exception to throw when a feature that needs jackson-databind is used without it.
+ *
+ * @param feature the feature that needs jackson-databind, for example {@code "@DynamoDBTypeConvertedJson"}
+ */
+ static DynamoDBMappingException missing(String feature) {
+ return new DynamoDBMappingException(
+ feature + " requires jackson-databind, which the mapper doesn't include. Add "
+ + "com.fasterxml.jackson.core:jackson-databind (Brazil package Jackson-databind) to the classpath, where "
+ + "the mapper's class loader can load it.");
+ }
+
+ /**
+ * Prepares the shared {@code ObjectMapper}, so that a missing or unusable jackson-databind fails when the mapper
+ * builds the model rather than on the first save or load.
+ */
+ static void initialize() {
+ BRIDGE.getValue();
+ }
+
+ /**
+ * Writes {@code value} as JSON, as {@code ObjectMapper.writeValueAsString} does.
+ *
+ * @throws Exception the exception jackson-databind threw
+ */
+ static String writeValueAsString(Object value) throws Exception {
+ ObjectMapperBridge bridge = BRIDGE.getValue();
+ return (String) invoke(bridge.writeValueAsString, bridge.objectMapper, value);
+ }
+
+ /**
+ * Reads {@code json} as {@code type}, as {@code ObjectMapper.readValue(String, Class)} does.
+ *
+ * @throws Exception the exception jackson-databind threw
+ */
+ @SuppressWarnings("unchecked")
+ static T readValue(String json, Class type) throws Exception {
+ ObjectMapperBridge bridge = BRIDGE.getValue();
+ return (T) invoke(bridge.readValue, bridge.objectMapper, json, type);
+ }
+
+ /**
+ * Calls {@code method} and rethrows what it threw, rather than an {@link InvocationTargetException}, so callers see
+ * the same exceptions as a direct call.
+ */
+ private static Object invoke(Method method, Object target, Object... args) throws Exception {
+ try {
+ return method.invoke(target, args);
+ } catch (InvocationTargetException e) {
+ Throwable cause = e.getCause();
+ if (cause instanceof Exception) {
+ throw (Exception) cause;
+ }
+ if (cause instanceof Error) {
+ throw (Error) cause;
+ }
+ throw e;
+ }
+ }
+
+ private static boolean isLoadable(String className) {
+ try {
+ Class.forName(className, false, JacksonDatabindSupport.class.getClassLoader());
+ return true;
+ } catch (ClassNotFoundException | LinkageError e) {
+ return false;
+ }
+ }
+
+ private static final class ObjectMapperBridge {
+ private final Object objectMapper;
+ private final Method writeValueAsString;
+ private final Method readValue;
+
+ private ObjectMapperBridge(Object objectMapper, Method writeValueAsString, Method readValue) {
+ this.objectMapper = objectMapper;
+ this.writeValueAsString = writeValueAsString;
+ this.readValue = readValue;
+ }
+
+ @SuppressWarnings({"unchecked", "rawtypes"})
+ private static ObjectMapperBridge create() {
+ if (!AVAILABLE) {
+ throw missing("@DynamoDBTypeConvertedJson");
+ }
+ try {
+ ClassLoader loader = JacksonDatabindSupport.class.getClassLoader();
+ Class> mapperClass = Class.forName(OBJECT_MAPPER_CLASS, true, loader);
+ Class extends Enum> featureClass =
+ (Class extends Enum>) Class.forName(DESERIALIZATION_FEATURE_CLASS, true, loader);
+
+ Object objectMapper = mapperClass.getConstructor().newInstance();
+ mapperClass.getMethod("disable", featureClass)
+ .invoke(objectMapper, Enum.valueOf(featureClass, "FAIL_ON_UNKNOWN_PROPERTIES"));
+
+ return new ObjectMapperBridge(objectMapper,
+ mapperClass.getMethod("writeValueAsString", Object.class),
+ mapperClass.getMethod("readValue", String.class, Class.class));
+ } catch (ReflectiveOperationException | LinkageError | IllegalArgumentException e) {
+ throw new DynamoDBMappingException(
+ "@DynamoDBTypeConvertedJson found jackson-databind on the classpath but couldn't use it. It "
+ + "requires jackson-databind 2.x.", e);
+ }
+ }
+ }
+}
diff --git a/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/DynamoDBMapperWithoutJacksonDatabindTest.java b/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/DynamoDBMapperWithoutJacksonDatabindTest.java
new file mode 100644
index 000000000000..1702b6318b36
--- /dev/null
+++ b/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/DynamoDBMapperWithoutJacksonDatabindTest.java
@@ -0,0 +1,146 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ * http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file 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 software.amazon.awssdk.mapper.dynamodb;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.assertj.core.api.Assertions.catchThrowable;
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
+
+import java.util.Map;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import software.amazon.awssdk.auth.credentials.AnonymousCredentialsProvider;
+import software.amazon.awssdk.regions.Region;
+import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
+import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
+
+/**
+ * Checks that the mapper works without jackson-databind, which it doesn't depend on, and that
+ * {@link DynamoDBTypeConvertedJson} fails with a clear message when the application doesn't provide it.
+ *
+ *
The {@code without-jackson-databind} surefire execution runs this class with jackson-databind removed from the
+ * classpath. Elsewhere, for example in an IDE, it is skipped.
+ */
+class DynamoDBMapperWithoutJacksonDatabindTest {
+
+ private final DynamoDBMapper mapper = DynamoDBMapper.builder()
+ .dynamoDbClient(DynamoDbClient.builder()
+ .region(Region.US_EAST_1)
+ .credentialsProvider(AnonymousCredentialsProvider.create())
+ .build())
+ .build();
+
+ @BeforeAll
+ static void requireJacksonDatabindExcluded() {
+ assumeTrue(Boolean.getBoolean("mapper.test.jacksonDatabindExcluded"),
+ "runs only in the without-jackson-databind surefire execution");
+ assertThatThrownBy(() -> Class.forName("com.fasterxml.jackson.databind.ObjectMapper"))
+ .as("jackson-databind must not be on the classpath of this test")
+ .isInstanceOf(ClassNotFoundException.class);
+ }
+
+ @Test
+ void isAvailable_withoutJacksonDatabind_returnsFalse() {
+ assertThat(JacksonDatabindSupport.isAvailable()).isFalse();
+ }
+
+ @Test
+ void getTableModel_withoutJsonAttribute_convertsWithoutJacksonDatabind() {
+ PlainItem item = new PlainItem();
+ item.setId("1");
+ item.setName("plain string");
+
+ DynamoDBMapperTableModel model = mapper.getTableModel(PlainItem.class);
+ Map stored = model.convert(item);
+
+ assertThat(stored.get("name").s()).isEqualTo("plain string");
+ assertThat(model.unconvert(stored).getName()).isEqualTo("plain string");
+ }
+
+ @Test
+ void getTableModel_withJsonAttribute_throwsMissingJacksonDatabindMessage() {
+ Throwable thrown = catchThrowable(() -> mapper.getTableModel(JsonItem.class));
+
+ assertThat(thrown).isInstanceOf(DynamoDBMappingException.class);
+ Throwable root = thrown;
+ while (root.getCause() != null) {
+ root = root.getCause();
+ }
+ assertThat(root)
+ .isInstanceOf(DynamoDBMappingException.class)
+ .hasMessageContaining("@DynamoDBTypeConvertedJson requires jackson-databind")
+ .hasMessageContaining("com.fasterxml.jackson.core:jackson-databind")
+ .hasMessageContaining("Jackson-databind");
+ }
+
+ public static class PlainItem {
+ private String id;
+ private String name;
+
+ @DynamoDBHashKey
+ public String getId() {
+ return id;
+ }
+
+ public void setId(String id) {
+ this.id = id;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+ }
+
+ public static class JsonItem {
+ private String id;
+ private Payload payload;
+
+ @DynamoDBHashKey
+ public String getId() {
+ return id;
+ }
+
+ public void setId(String id) {
+ this.id = id;
+ }
+
+ @DynamoDBTypeConvertedJson
+ public Payload getPayload() {
+ return payload;
+ }
+
+ public void setPayload(Payload payload) {
+ this.payload = payload;
+ }
+ }
+
+ public static class Payload {
+ private String value;
+
+ public String getValue() {
+ return value;
+ }
+
+ public void setValue(String value) {
+ this.value = value;
+ }
+ }
+}
diff --git a/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/DynamoDBTypeConvertedJsonTest.java b/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/DynamoDBTypeConvertedJsonTest.java
new file mode 100644
index 000000000000..fea560964a73
--- /dev/null
+++ b/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/DynamoDBTypeConvertedJsonTest.java
@@ -0,0 +1,187 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ * http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file 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 software.amazon.awssdk.mapper.dynamodb;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Map;
+import org.junit.jupiter.api.Test;
+import software.amazon.awssdk.auth.credentials.AnonymousCredentialsProvider;
+import software.amazon.awssdk.regions.Region;
+import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
+import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
+
+class DynamoDBTypeConvertedJsonTest {
+
+ private final DynamoDBMapper mapper = DynamoDBMapper.builder()
+ .dynamoDbClient(DynamoDbClient.builder()
+ .region(Region.US_EAST_1)
+ .credentialsProvider(AnonymousCredentialsProvider.create())
+ .build())
+ .build();
+
+ @Test
+ void isAvailable_withJacksonDatabind_returnsTrue() {
+ assertThat(JacksonDatabindSupport.isAvailable()).isTrue();
+ }
+
+ @Test
+ void getTableModel_jsonAttribute_storesJsonStringAndReadsItBack() {
+ JsonItem item = new JsonItem();
+ item.setId("1");
+ item.setCurrency(new Currency(79.99, "USD"));
+
+ DynamoDBMapperTableModel model = mapper.getTableModel(JsonItem.class);
+ Map stored = model.convert(item);
+
+ assertThat(stored.get("currency").s()).isEqualTo("{\"amount\":79.99,\"unit\":\"USD\"}");
+ Currency loaded = model.unconvert(stored).getCurrency();
+ assertThat(loaded.getAmount()).isEqualTo(79.99);
+ assertThat(loaded.getUnit()).isEqualTo("USD");
+ }
+
+ @Test
+ void getTableModel_targetType_readsIntoTargetType() {
+ ListItem item = new ListItem();
+ item.setId("1");
+ CurrencyList currencies = new CurrencyList();
+ currencies.addAll(Arrays.asList(new Currency(1.0, "EUR"), new Currency(2.0, "GBP")));
+ item.setCurrencies(currencies);
+
+ DynamoDBMapperTableModel model = mapper.getTableModel(ListItem.class);
+ ListItem loaded = model.unconvert(model.convert(item));
+
+ assertThat(loaded.getCurrencies()).isInstanceOf(CurrencyList.class);
+ assertThat(loaded.getCurrencies()).extracting(Currency::getUnit).containsExactly("EUR", "GBP");
+ }
+
+ @Test
+ void unconvert_unknownProperty_isIgnored() {
+ Currency loaded = converter(Currency.class).unconvert("{\"amount\":1.0,\"unit\":\"EUR\",\"unknown\":true}");
+
+ assertThat(loaded.getUnit()).isEqualTo("EUR");
+ }
+
+ @Test
+ void unconvert_invalidJson_throwsMappingExceptionWithDatabindCause() {
+ assertThatThrownBy(() -> converter(Currency.class).unconvert("{not json"))
+ .isInstanceOf(DynamoDBMappingException.class)
+ .hasMessage("Unable to read JSON string")
+ .hasCauseInstanceOf(JsonProcessingException.class);
+ }
+
+ @Test
+ void convert_unserializableObject_throwsMappingExceptionWithDatabindCause() {
+ assertThatThrownBy(() -> converter(Object.class).convert(new Object()))
+ .isInstanceOf(DynamoDBMappingException.class)
+ .hasMessage("Unable to write object to JSON")
+ .hasCauseInstanceOf(JsonMappingException.class);
+ }
+
+ @SuppressWarnings({"unchecked", "rawtypes"})
+ private static DynamoDBTypeConvertedJson.Converter converter(Class type) {
+ try {
+ DynamoDBTypeConvertedJson annotation =
+ JsonItem.class.getMethod("getCurrency").getAnnotation(DynamoDBTypeConvertedJson.class);
+ return new DynamoDBTypeConvertedJson.Converter(type, annotation);
+ } catch (NoSuchMethodException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ public static class JsonItem {
+ private String id;
+ private Currency currency;
+
+ @DynamoDBHashKey
+ public String getId() {
+ return id;
+ }
+
+ public void setId(String id) {
+ this.id = id;
+ }
+
+ @DynamoDBTypeConvertedJson
+ public Currency getCurrency() {
+ return currency;
+ }
+
+ public void setCurrency(Currency currency) {
+ this.currency = currency;
+ }
+ }
+
+ public static class ListItem {
+ private String id;
+ private CurrencyList currencies;
+
+ @DynamoDBHashKey
+ public String getId() {
+ return id;
+ }
+
+ public void setId(String id) {
+ this.id = id;
+ }
+
+ @DynamoDBTypeConvertedJson(targetType = CurrencyList.class)
+ public CurrencyList getCurrencies() {
+ return currencies;
+ }
+
+ public void setCurrencies(CurrencyList currencies) {
+ this.currencies = currencies;
+ }
+ }
+
+ public static class CurrencyList extends ArrayList {
+ }
+
+ public static class Currency {
+ private Double amount;
+ private String unit;
+
+ public Currency() {
+ }
+
+ Currency(Double amount, String unit) {
+ this.amount = amount;
+ this.unit = unit;
+ }
+
+ public Double getAmount() {
+ return amount;
+ }
+
+ public void setAmount(Double amount) {
+ this.amount = amount;
+ }
+
+ public String getUnit() {
+ return unit;
+ }
+
+ public void setUnit(String unit) {
+ this.unit = unit;
+ }
+ }
+}
diff --git a/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/StandardModelFactoriesEdgeCasesTest.java b/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/StandardModelFactoriesEdgeCasesTest.java
index 77358daaba3c..acb3dcc9135d 100644
--- a/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/StandardModelFactoriesEdgeCasesTest.java
+++ b/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/StandardModelFactoriesEdgeCasesTest.java
@@ -48,7 +48,7 @@ public class StandardModelFactoriesEdgeCasesTest {
.withConversionSchema(ConversionSchemas.V2)
.build();
- private static final DynamoDBMapperModelFactory factory = StandardModelFactories.of(S3Link.Factory.of(null));
+ private static final DynamoDBMapperModelFactory factory = StandardModelFactories.of();
private static final DynamoDBMapperModelFactory.TableFactory v1Models = factory.getTableFactory(V1_CONFIG);
private static final DynamoDBMapperModelFactory.TableFactory v2Models = factory.getTableFactory(V2_CONFIG);
From e7322fee107e1cf4231ed9bb6f586569105f9d36 Mon Sep 17 00:00:00 2001
From: RanVaknin <50976344+RanVaknin@users.noreply.github.com>
Date: Fri, 20 Nov 2026 14:05:59 -0800
Subject: [PATCH 3/3] Add v1 fixture compliance tests
Check @DynamoDBTypeConvertedJson against JSON recorded from v1's
converter (aws-java-sdk-dynamodb 1.12.797 on jackson-databind 2.17.2)
over 145 cases. Writes must match byte for byte. Classes with
getter-only properties are compared without regard to property order,
because jackson-databind orders those by getDeclaredMethods(), which
differs between JVMs even in v1.
---
...BTypeConvertedJsonV1CompatibilityTest.java | 144 ++
.../jsonfixtures/JsonModelFixtures.java | 1400 +++++++++++++++++
.../type_converted_json_fixture.json | 147 ++
3 files changed, 1691 insertions(+)
create mode 100644 services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/DynamoDBTypeConvertedJsonV1CompatibilityTest.java
create mode 100644 services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/jsonfixtures/JsonModelFixtures.java
create mode 100644 services-custom/dynamodb-mapper/src/test/resources/type_converted_json_fixture.json
diff --git a/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/DynamoDBTypeConvertedJsonV1CompatibilityTest.java b/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/DynamoDBTypeConvertedJsonV1CompatibilityTest.java
new file mode 100644
index 000000000000..97453e6e8223
--- /dev/null
+++ b/services-custom/dynamodb-mapper/src/test/java/software/amazon/awssdk/mapper/dynamodb/DynamoDBTypeConvertedJsonV1CompatibilityTest.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ * http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file 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 software.amazon.awssdk.mapper.dynamodb;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UncheckedIOException;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Stream;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import software.amazon.awssdk.mapper.dynamodb.jsonfixtures.JsonModelFixtures;
+import software.amazon.awssdk.mapper.dynamodb.jsonfixtures.JsonModelFixtures.ReadCase;
+
+/**
+ * Checks {@link DynamoDBTypeConvertedJson.Converter} against JSON recorded from the v1 mapper.
+ *
+ *
{@code type_converted_json_fixture.json} holds the output of v1's
+ * {@code com.amazonaws.services.dynamodbv2.datamodeling.DynamoDBTypeConvertedJson.Converter} from
+ * {@code aws-java-sdk-dynamodb} 1.12.797, running on jackson-databind 2.17.2, the version that release depends on,
+ * for every case in {@link JsonModelFixtures}. Write cases hold the JSON v1 wrote; read cases hold the object v1 read,
+ * serialized again with a default {@code ObjectMapper}.
+ */
+class DynamoDBTypeConvertedJsonV1CompatibilityTest {
+
+ private static final String FIXTURE = "type_converted_json_fixture.json";
+
+ /**
+ * Classes with properties that have a getter but no field. jackson-databind orders those properties by
+ * {@code Class.getDeclaredMethods()}, which the JVM doesn't specify, so their JSON can differ between JVMs even in
+ * v1. Cases that include them are compared without regard to property order.
+ */
+ private static final Set GETTER_ONLY_CLASSES = new HashSet<>(Arrays.asList(
+ "SubclassWithFieldsAndGetters", "OverridesGetter", "GetterOnly", "ManglesGetterNames", "IsGetters"));
+
+ private static final ObjectMapper JSON = new ObjectMapper();
+
+ private static final Map RECORDED = load();
+
+ private static final DynamoDBTypeConvertedJson ANNOTATION = annotation();
+
+ @DynamoDBTypeConvertedJson
+ private Object holder;
+
+ static Stream writeCases() {
+ List