Steuern Sie die Attributkonvertierung

Standardmäßig stellt ein Tabellenschema über eine Standardimplementierung der AttributeConverterProvider Schnittstelle Konverter für viele gängige Java-Typen bereit. Sie können das allgemeine Standardverhalten mit einer benutzerdefinierten AttributeConverterProvider Implementierung ändern. Sie können den Konverter auch für ein einzelnes Attribut ändern.

Eine Liste der verfügbaren Konverter finden Sie in der AttributeConverterJava-Dokumentation zur Schnittstelle.

Stellen Sie Anbieter für benutzerdefinierte Attributkonverter bereit

Sie können über die @DynamoDbBean (converterProviders = {…}) Anmerkung ein einzelnes AttributeConverterProvider oder eine Kette von bestellten AttributeConverterProvider S angeben. Jeder benutzerdefinierte AttributeConverterProvider Benutzer muss die AttributeConverterProvider Schnittstelle erweitern.

Beachten Sie, dass Sie, wenn Sie Ihre eigene Kette von Anbietern für Attributkonverter angeben, den Standardkonverter-Anbieter außer Kraft setzenDefaultAttributeConverterProvider. Wenn Sie die Funktionalität von verwenden möchtenDefaultAttributeConverterProvider, müssen Sie sie in die Kette aufnehmen.

Es ist auch möglich, die Bean mit einem leeren Array {} zu annotieren. Dadurch wird die Verwendung aller Anbieter für Attributkonverter deaktiviert, einschließlich der Standardanbieter. In diesem Fall müssen alle Attribute, die zugeordnet werden sollen, über einen eigenen Attributkonverter verfügen.

Das folgende Snippet zeigt einen einzelnen Konverter-Anbieter.

@DynamoDbBean(converterProviders = ConverterProvider1.class)
public class Customer {

}

Der folgende Ausschnitt zeigt die Verwendung einer Kette von Konverteranbietern. Da der SDK-Standard zuletzt bereitgestellt wird, hat er die niedrigste Priorität.

@DynamoDbBean(converterProviders = {
   ConverterProvider1.class, 
   ConverterProvider2.class,
   DefaultAttributeConverterProvider.class})
public class Customer {

}

Die Schema-Builder für statische Tabellen verfügen über eine attributeConverterProviders() Methode, die auf die gleiche Weise funktioniert. Dies wird im folgenden Snippet gezeigt.

private static final StaticTableSchema<Customer> CUSTOMER_TABLE_SCHEMA =
  StaticTableSchema.builder(Customer.class)
    .newItemSupplier(Customer::new)
    .addAttribute(String.class, a -> a.name("name")
                                     a.getter(Customer::getName)
                                     a.setter(Customer::setName))
    .attributeConverterProviders(converterProvider1, converterProvider2)
    .build();

Überschreiben Sie die Zuordnung eines einzelnen Attributs

Um die Art und Weise, wie ein einzelnes Attribut zugeordnet wird, zu überschreiben, geben Sie an AttributeConverter für das Attribut ein. Dieser Zusatz hat Vorrang vor allen Konvertern, die von AttributeConverterProviders im Tabellenschema bereitgestellt werden. Dadurch wird ein benutzerdefinierter Konverter nur für dieses Attribut hinzugefügt. Andere Attribute, auch solche desselben Typs, verwenden diesen Konverter nur, wenn er explizit für diese anderen Attribute angegeben ist.

Die @DynamoDbConvertedBy Anmerkung wird verwendet, um die benutzerdefinierte AttributeConverter Klasse anzugeben, wie im folgenden Codeausschnitt gezeigt.

@DynamoDbBean
public class Customer {
    private String name;

    @DynamoDbConvertedBy(CustomAttributeConverter.class)
    public String getName() { return this.name; }
    public void setName(String name) { this.name = name;}
}

Die Builder für statische Schemas verfügen über eine entsprechende Methode zur Erstellung von Attributen. attributeConverter() Diese Methode benötigt eine Instanz von a, AttributeConverter wie im Folgenden gezeigt.

private static final StaticTableSchema<Customer> CUSTOMER_TABLE_SCHEMA =
  StaticTableSchema.builder(Customer.class)
    .newItemSupplier(Customer::new)
    .addAttribute(String.class, a -> a.name("name")
                                     a.getter(Customer::getName)
                                     a.setter(Customer::setName)
                                     a.attributeConverter(customAttributeConverter))
    .build();

Beispiel

Dieses Beispiel zeigt eine AttributeConverterProvider Implementierung, die einen Attributkonverter für java.net.HttpCookieObjekte bereitstellt.

Die folgende SimpleUser Klasse enthält ein Attribut mit dem NamenlastUsedCookie, das eine Instanz von istHttpCookie.

Der Parameter für die @DynamoDbBean Anmerkungen listet die beiden AttributeConverterProvider Klassen auf, die Konverter bereitstellen.

Class with annotations

    @DynamoDbBean(converterProviders = {CookieConverterProvider.class, DefaultAttributeConverterProvider.class})
    public static final class SimpleUser {
        private String name;
        private HttpCookie lastUsedCookie;

        @DynamoDbPartitionKey
        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public HttpCookie getLastUsedCookie() {
            return lastUsedCookie;
        }

        public void setLastUsedCookie(HttpCookie lastUsedCookie) {
            this.lastUsedCookie = lastUsedCookie;
        }

Static table schema

    private static final TableSchema<SimpleUser> SIMPLE_USER_TABLE_SCHEMA =
            TableSchema.builder(SimpleUser.class)
                    .newItemSupplier(SimpleUser::new)
                    .attributeConverterProviders(CookieConverterProvider.create(), AttributeConverterProvider.defaultProvider())
                    .addAttribute(String.class, a -> a.name("name")
                            .setter(SimpleUser::setName)
                            .getter(SimpleUser::getName)
                            .tags(StaticAttributeTags.primaryPartitionKey()))
                    .addAttribute(HttpCookie.class, a -> a.name("lastUsedCookie")
                            .setter(SimpleUser::setLastUsedCookie)
                            .getter(SimpleUser::getLastUsedCookie))
                    .build();

Das CookieConverterProvider folgende Beispiel bietet eine Instanz HttpCookeConverter von.

    public static final class CookieConverterProvider implements AttributeConverterProvider {
        private final Map<EnhancedType<?>, AttributeConverter<?>> converterCache = ImmutableMap.of(
                // 1. Add HttpCookieConverter to the internal cache.
                EnhancedType.of(HttpCookie.class), new HttpCookieConverter());

        public static CookieConverterProvider create() {
            return new CookieConverterProvider();
        }

        // The SDK calls this method to find out if the provider contains a AttributeConverter instance
        // for the EnhancedType<T> argument.
        @SuppressWarnings("unchecked")
        @Override
        public <T> AttributeConverter<T> converterFor(EnhancedType<T> enhancedType) {
            return (AttributeConverter<T>) converterCache.get(enhancedType);
        }
    }

Konvertierungscode

In der transformFrom() Methode der folgenden HttpCookieConverter Klasse empfängt der Code eine HttpCookie Instanz und wandelt sie in eine DynamoDB-Map um, die als Attribut gespeichert wird.

Die transformTo() Methode empfängt einen DynamoDB-Zuordnungsparameter und ruft dann den HttpCookie Konstruktor auf, der einen Namen und einen Wert benötigt.

    public static final class HttpCookieConverter implements AttributeConverter<HttpCookie> {

        @Override
        public AttributeValue transformFrom(HttpCookie httpCookie) {

            return AttributeValue.fromM(
            Map.of ("cookieName", AttributeValue.fromS(httpCookie.getName()),
                    "cookieValue", AttributeValue.fromS(httpCookie.getValue()))
            );
        }

        @Override
        public HttpCookie transformTo(AttributeValue attributeValue) {
            Map<String, AttributeValue> map = attributeValue.m();
            return new HttpCookie(
                    map.get("cookieName").s(),
                    map.get("cookieValue").s());
        }

        @Override
        public EnhancedType<HttpCookie> type() {
            return EnhancedType.of(HttpCookie.class);
        }

        @Override
        public AttributeValueType attributeValueType() {
            return AttributeValueType.M;
        }
    }