Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Steuern Sie die Attributkonvertierung
Standardmäßig stellt ein Tabellenschema über eine Standardimplementierung der `[AttributeConverterProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/AttributeConverterProvider.html)` Schnittstelle Konverter für viele gängige Java-Typen bereit. Das allgemeine Standardverhalten lässt sich durch eine benutzerdefinierte `AttributeConverterProvider`-Implementierung ändern. Ebenso können Sie den Konverter für ein einzelnes Attribut anpassen.
Eine Liste der verfügbaren Konverter finden Sie im Java-Dokument zur [AttributeConverter](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/AttributeConverter.html)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 setzen`DefaultAttributeConverterProvider`. Wenn Sie die Funktionalität von verwenden möchten`DefaultAttributeConverterProvider`, 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.
Der folgende Ausschnitt 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 Ausschnitt gezeigt.
```
private static final StaticTableSchema 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_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 [https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/net/HttpCookie.html](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/net/HttpCookie.html)Objekte bereitstellt.
Die folgende `SimpleUser` Klasse enthält ein Attribut mit dem Namen`lastUsedCookie`, das eine Instanz von ist`HttpCookie`.
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 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, 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 argument.
@SuppressWarnings("unchecked")
@Override
public AttributeConverter converterFor(EnhancedType enhancedType) {
return (AttributeConverter) 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 {
@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 map = attributeValue.m();
return new HttpCookie(
map.get("cookieName").s(),
map.get("cookieValue").s());
}
@Override
public EnhancedType type() {
return EnhancedType.of(HttpCookie.class);
}
@Override
public AttributeValueType attributeValueType() {
return AttributeValueType.M;
}
}
```