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.

# Java 1.x: Dynamo DBMapper
<a name="DynamoDBMapper"></a>

**Anmerkung**  
Das SDK für Java ist in zwei Versionen verfügbar: 1.x und 2.x. Die Version end-of-support für 1.x wurde [am 12. Januar 2024 angekündigt](https://aws.amazon.com/blogs/developer/announcing-end-of-support-for-aws-sdk-for-java-v1-x-on-december-31-2025/). Es wird und end-of-support ist am 31. Dezember 2025 fällig. Für Neuentwicklungen wird die Verwendung von Version 2.x empfohlen.

Die AWS SDK für Java stellt eine `DynamoDBMapper` Klasse bereit, mit der Sie Ihre clientseitigen Klassen Amazon DynamoDB-Tabellen zuordnen können. Um `DynamoDBMapper` zu verwenden, definieren Sie die Beziehung zwischen Elementen in einer DynamoDB-Tabelle und ihren entsprechenden Objekt-Instances im Code. Die `DynamoDBMapper`-Klasse ermöglicht Ihnen auch die Ausführung verschiedener Create-, Read-, Update-, und Delete-Operationen (CRUD) für Elemente sowie das Ausführen von Abfragen und Scans für Tabellen.

**Topics**
+ [Dynamo-Klasse DBMapper](DynamoDBMapper.Methods.md)
+ [Unterstützte Datentypen für Dynamo DBMapper für Java](DynamoDBMapper.DataTypes.md)
+ [Java-Anmerkungen für DynamoDB](DynamoDBMapper.Annotations.md)
+ [Optionale Konfigurationseinstellungen für Dynamo DBMapper](DynamoDBMapper.OptionalConfig.md)
+ [DynamoDB und optimistische Sperren mit Versionsnummer](DynamoDBMapper.OptimisticLocking.md)
+ [Zuordnen willkürlicher Daten in DynamoDB](DynamoDBMapper.ArbitraryDataMapping.md)
+ [Beispiele für DynamoDBMapper](DynamoDBMapper.Examples.md)

**Anmerkung**  
Die `DynamoDBMapper`-Klasse erlaubt kein Erstellen, Aktualisieren oder Löschen von Tabellen. Zum Ausführen dieser Aufgaben verwenden Sie stattdessen die Low-Level-SDK-für-Java-Schnittstelle. 

Das SDK für Java stellt eine Reihe von Anmerkungstypen bereit, damit Sie Ihre Klassen zu Tabellen zuweisen können. Betrachten Sie beispielsweise eine `ProductCatalog`-Tabelle, die `Id` als Partitionsschlüssel verwendet. 

```
ProductCatalog(Id, ...)
```

Sie können der `ProductCatalog`-Tabelle eine Klasse in Ihrer Client-Anwendung zuweisen wie im folgenden Java-Code gezeigt. Diese Code definiert ein Plain Old Java Object (POJO) mit dem Namen `CatalogItem`, das Anmerkungen verwendet, um Objektfelder zu DynamoDB-Attributnamen zuzuweisen:

**Example**  

```
package com.amazonaws.codesamples;

import java.util.Set;

import software.amazon.dynamodb.datamodeling.DynamoDBAttribute;
import software.amazon.dynamodb.datamodeling.DynamoDBHashKey;
import software.amazon.dynamodb.datamodeling.DynamoDBIgnore;
import software.amazon.dynamodb.datamodeling.DynamoDBTable;

@DynamoDBTable(tableName="ProductCatalog")
public class CatalogItem {

    private Integer id;
    private String title;
    private String ISBN;
    private Set<String> bookAuthors;
    private String someProp;

    @DynamoDBHashKey(attributeName="Id")
    public Integer getId() { return id; }
    public void setId(Integer id) {this.id = id; }

    @DynamoDBAttribute(attributeName="Title")
    public String getTitle() {return title; }
    public void setTitle(String title) { this.title = title; }

    @DynamoDBAttribute(attributeName="ISBN")
    public String getISBN() { return ISBN; }
    public void setISBN(String ISBN) { this.ISBN = ISBN; }

    @DynamoDBAttribute(attributeName="Authors")
    public Set<String> getBookAuthors() { return bookAuthors; }
    public void setBookAuthors(Set<String> bookAuthors) { this.bookAuthors = bookAuthors; }

    @DynamoDBIgnore
    public String getSomeProp() { return someProp; }
    public void setSomeProp(String someProp) { this.someProp = someProp; }
}
```

Im vorherigen Code weist die Anmerkung `@DynamoDBTable` die Klasse `CatalogItem` der Tabelle `ProductCatalog` zu. Sie können einzelne Klassen-Instances als Elemente in der Tabelle speichern. Die Anmerkung `@DynamoDBHashKey` weist die Eigenschaft `Id` dem Primärschlüssel zu. 

Standardmäßig sind die Klasseneigenschaften denselben Attributnamen in der Tabelle zugeordnet. Die Eigenschaften `Title` und `ISBN` sind den gleichen Attributnamen in der Tabelle zugeordnet. 

Die `@DynamoDBAttribute`-Anmerkung ist optional, wenn der Name des DynamoDB-Attributs dem Namen der in der Klasse angegebenen Eigenschaft entspricht. Wenn sich die Namen unterscheiden, verwenden Sie diese Anmerkung mit dem Parameter `attributeName`, um anzugeben, mit welchem DynamoDB-Attribut diese Eigenschaft übereinstimmt. 

Im vorangegangenen Beispiel wird jeder Eigenschaft die Annotation `@DynamoDBAttribute` hinzugefügt, um sicherzustellen, dass Eigenschaftsnamen genau den Tabellen entsprechen, die in einem vorherigen Schritt erstellt wurden und um die Attributnamen, die in anderen Codebeispielen in diesem Handbuch verwendet werden, einzuhalten. 

Ihre Klassendefinition kann Eigenschaften besitzen, die keinen Attributen in der Tabelle zugeordnet sind. Sie erkennen diese Eigenschaften, indem Sie die `@DynamoDBIgnore`-Anmerkung hinzufügen. Im vorangegangenen Beispiel ist die `SomeProp`-Eigenschaft mit der `@DynamoDBIgnore`-Anmerkung gekennzeichnet. Wenn Sie eine `CatalogItem`-Instance in die Tabelle hochladen, enthält Ihre `DynamoDBMapper`-Instance die Eigenschaft `SomeProp` nicht. Darüber hinaus gibt der Mapper dieses Attribut nicht zurück, wenn Sie ein Element aus der Tabelle abrufen. 

Nachdem Sie die Mappingklasse definierthaben, können Sie `DynamoDBMapper`-Methoden verwenden, um eine Instance dieser Klasse zu einem entsprechenden Element in der Tabelle `Catalog` zu schreiben. Das folgende Codebeispiel zeigt diese Technik.

```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();

DynamoDBMapper mapper = new DynamoDBMapper(client);

CatalogItem item = new CatalogItem();
item.setId(102);
item.setTitle("Book 102 Title");
item.setISBN("222-2222222222");
item.setBookAuthors(new HashSet<String>(Arrays.asList("Author 1", "Author 2")));
item.setSomeProp("Test");

mapper.save(item);
```

Im folgenden Codebeispiel wird gezeigt, wie Sie das Element abrufen und auf einige seiner Attribute zugreifen.

```
CatalogItem partitionKey = new CatalogItem();

partitionKey.setId(102);
DynamoDBQueryExpression<CatalogItem> queryExpression = new DynamoDBQueryExpression<CatalogItem>()
    .withHashKeyValues(partitionKey);

List<CatalogItem> itemList = mapper.query(CatalogItem.class, queryExpression);

for (int i = 0; i < itemList.size(); i++) {
    System.out.println(itemList.get(i).getTitle());
    System.out.println(itemList.get(i).getBookAuthors());
}
```

`DynamoDBMapper` ermöglicht ein intuitives und natürliches Arbeiten mit DynamoDB-Daten in Java. Er bietet auch verschiedene integrierte Funktionen wie optimistische Sperre, ACID-Transaktionen, automatisch generierte Partitions- und Sortierschlüsselwerte sowie Objektversionierung.