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.
# Programmieren mit DynamoDB und AWS SDKs
Where:
tableName - The Amazon DynamoDB table from which an item is retrieved (for example, Music3).\s
key - The key used in the Amazon DynamoDB table (for example, Artist).\s
keyval - The key value that represents the item to get (for example, Famous Band).
""";
if (args.length != 3) {
System.out.println(usage);
System.exit(1);
}
String tableName = args[0];
String key = args[1];
String keyVal = args[2];
System.out.format("Retrieving item \"%s\" from \"%s\"\n", keyVal, tableName);
Region region = Region.US_EAST_1;
DynamoDbClient ddb = DynamoDbClient.builder()
.region(region)
.build();
getDynamoDBItem(ddb, tableName, key, keyVal);
ddb.close();
}
public static void getDynamoDBItem(DynamoDbClient ddb, String tableName, String key, String keyVal) {
HashMap keyToGet = new HashMap<>();
keyToGet.put(key, AttributeValue.builder()
.s(keyVal)
.build());
GetItemRequest request = GetItemRequest.builder()
.key(keyToGet)
.tableName(tableName)
.build();
try {
// If there is no matching item, GetItem does not return any data.
Map returnedItem = ddb.getItem(request).item();
if (returnedItem.isEmpty())
System.out.format("No item found with the key %s!\n", key);
else {
Set keys = returnedItem.keySet();
System.out.println("Amazon DynamoDB table attributes: \n");
for (String key1 : keys) {
System.out.format("%s: %s\n", key1, returnedItem.get(key1).toString());
}
}
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
}
```
## Dokumentschnittstellen, die mit DynamoDB funktionieren
table = enhancedClient.table("Customer", TableSchema.fromBean(Customer.class));
Key key = Key.builder()
.partitionValue("id101").sortValue("tred@noserver.com")
.build();
// Get the item by using the key.
result = table.getItem(
(GetItemEnhancedRequest.Builder requestBuilder) -> requestBuilder.key(key));
System.out.println("******* The description value is " + result.getCustName());
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
System.exit(1);
}
return result.getCustName();
}
}
```
# Higher-Level-Programmierschnittstellen für DynamoDB
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 getBookAuthors() { return bookAuthors; }
public void setBookAuthors(Set 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(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 queryExpression = new DynamoDBQueryExpression()
.withHashKeyValues(partitionKey);
List 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.
# Dynamo-Klasse DBMapper
eav = new HashMap();
eav.put(":v1", new AttributeValue().withS(partitionKey));
eav.put(":v2",new AttributeValue().withS(twoWeeksAgoStr.toString()));
DynamoDBQueryExpression queryExpression = new DynamoDBQueryExpression()
.withKeyConditionExpression("Id = :v1 and ReplyDateTime > :v2")
.withExpressionAttributeValues(eav);
List latestReplies = mapper.query(Reply.class, queryExpression);
```
Die Abfrage gibt eine Sammlung von `Reply`-Objekten zurück.
Die `query`-Methode gibt standardmäßig eine "lazy-loaded"-Sammlung zurück. Sie gibt anfänglich ausschließlich eine Ergebnisseite zurück und führt dann bei Bedarf einen Dienstaufruf für die nächste Seite durch. Um alle übereinstimmenden Elemente zu erhalten, müssen Sie die Sammlung `latestReplies` durchlaufen.
Beachten Sie, dass beim Aufrufen der `size()`-Methode für die Sammlung jedes Ergebnis geladen wird, um eine genaue Zählung zu liefern. Dies kann dazu führen, dass viel bereitgestellter Durchsatz verbraucht wird, und bei einer sehr großen Tabelle könnte sogar der gesamte Speicher in Ihrer JVM ausgeschöpft werden.
Für eine Indexabfrage müssen Sie zuerst den Index als eine Mapper-Klasse modellieren. *Angenommen, die `Reply` Tabelle hat einen globalen sekundären Index namens -Message-Index. PostedBy* Der Partitionsschlüssel für diesen Index ist `PostedBy` und der Sortierschlüssel ist `Message`. Die Klassendefinition für ein Element im Index würde wie folgt aussehen.
```
@DynamoDBTable(tableName="Reply")
public class PostedByMessage {
private String postedBy;
private String message;
@DynamoDBIndexHashKey(globalSecondaryIndexName = "PostedBy-Message-Index", attributeName = "PostedBy")
public String getPostedBy() { return postedBy; }
public void setPostedBy(String postedBy) { this.postedBy = postedBy; }
@DynamoDBIndexRangeKey(globalSecondaryIndexName = "PostedBy-Message-Index", attributeName = "Message")
public String getMessage() { return message; }
public void setMessage(String message) { this.message = message; }
// Additional properties go here.
}
```
Die Anmerkung `@DynamoDBTable` gibt an, dass dieser Index mit der Tabelle `Reply` verknüpft ist. Die `@DynamoDBIndexHashKey` Anmerkung bezeichnet den Partitionsschlüssel (*PostedBy*) des Indexes und `@DynamoDBIndexRangeKey` den Sortierschlüssel (*Message*) des Indexes.
Sie können jetzt `DynamoDBMapper` nutzen, um den Index abzufragen, der eine Teilmenge der Nachrichten, die von einem bestimmten Benutzer gepostet wurden, abruft. Sie müssen den Indexnamen nicht angeben, wenn Sie keine widersprüchlichen Zuordnungen zwischen Tabellen und Indizes haben und die Zuordnungen bereits im Mapper vorgenommen wurden. Der Mapper leitet anhand des Primärschlüssels und des Sortierschlüssels ab. Der folgende Code fragt den globalen sekundären Index ab. Da globale sekundäre Indizes Eventually Consistent-Lesevorgänge, jedoch keine Strongly Consistent-Lesevorgänge unterstützen, müssen Sie `withConsistentRead(false)` angeben.
```
HashMap eav = new HashMap();
eav.put(":v1", new AttributeValue().withS("User A"));
eav.put(":v2", new AttributeValue().withS("DynamoDB"));
DynamoDBQueryExpression queryExpression = new DynamoDBQueryExpression()
.withIndexName("PostedBy-Message-Index")
.withConsistentRead(false)
.withKeyConditionExpression("PostedBy = :v1 and begins_with(Message, :v2)")
.withExpressionAttributeValues(eav);
List iList = mapper.query(PostedByMessage.class, queryExpression);
```
Die Abfrage gibt eine Sammlung von `PostedByMessage`-Objekten zurück.
## queryPage
eav = new HashMap();
eav.put(":v1", new AttributeValue().withS("2015"));
DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()
.withFilterExpression("begins_with(ReplyDateTime,:v1)")
.withExpressionAttributeValues(eav);
List replies = mapper.scan(Reply.class, scanExpression);
```
Die `scan`-Methode gibt standardmäßig eine "lazy-loaded"-Sammlung zurück. Sie gibt anfänglich ausschließlich eine Ergebnisseite zurück und führt dann bei Bedarf einen Dienstaufruf für die nächste Seite durch. Um alle übereinstimmenden Elemente zu erhalten, müssen Sie die Sammlung `replies` durchlaufen.
Beachten Sie, dass beim Aufrufen der `size()`-Methode für die Sammlung jedes Ergebnis geladen wird, um eine genaue Zählung zu liefern. Dies kann dazu führen, dass viel bereitgestellter Durchsatz verbraucht wird, und bei einer sehr großen Tabelle könnte sogar der gesamte Speicher in Ihrer JVM ausgeschöpft werden.
Um einen Index zu scannen, müssen Sie zuerst den Index als eine Mapper-Klasse modellieren. Angenommen, die `Reply`-Tabelle hat einen globalen sekundären Index namens `PostedBy-Message-Index`. Der Partitionsschlüssel für diesen Index ist `PostedBy` und der Sortierschlüssel ist `Message`. Im Abschnitt [query](#DynamoDBMapper.Methods.query) wird eine Mapper-Klasse für diesen Index gezeigt. Sie verwendet die Anmerkungen `@DynamoDBIndexHashKey` und `@DynamoDBIndexRangeKey`, um den Partitions- und Sortierschlüssel des Index anzugeben.
Im folgenden Codebeispiel wird `PostedBy-Message-Index` gescannt. Er verwendet keinen Scan-Filter, sodass alle Elemente im Index an Sie zurückgegeben werden.
```
DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()
.withIndexName("PostedBy-Message-Index")
.withConsistentRead(false);
List iList = mapper.scan(PostedByMessage.class, scanExpression);
Iterator indexItems = iList.iterator();
```
## scanPage
eav = new HashMap();
eav.put(":n", new AttributeValue().withN("100"));
DynamoDBScanExpression scanExpression = new DynamoDBScanExpression()
.withFilterExpression("Price <= :n")
.withExpressionAttributeValues(eav);
List scanResult = mapper.parallelScan(Product.class, scanExpression, numberOfThreads);
```
## batchSave
itemsToGet = new ArrayList();
ForumItem forumItem = new ForumItem();
forumItem.setForumName("Amazon DynamoDB");
itemsToGet.add(forumItem);
ThreadItem threadItem = new ThreadItem();
threadItem.setForumName("Amazon DynamoDB");
threadItem.setSubject("Amazon DynamoDB thread 1 message text");
itemsToGet.add(threadItem);
Map> items = mapper.batchLoad(itemsToGet);
```
## batchDelete
objectsToWrite = Arrays.asList(forumItem, threadItem);
List objectsToDelete = Arrays.asList(book3);
mapper.batchWrite(objectsToWrite, objectsToDelete);
```
## transactionWrite
getBookAuthors() { return BookAuthors; }
public void setBookAuthors(List BookAuthors) { this.BookAuthors = BookAuthors; }
```
Der `DynamoDBMapper` verwendet `Authors` als Attributnamen bei der Speicherung des Objekts in die Tabelle.
## Dynamo DBAuto GeneratedKey
bookAuthors;
private String someProp;
private Long version;
@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 getBookAuthors() { return bookAuthors; }
public void setBookAuthors(Set bookAuthors) { this.bookAuthors = bookAuthors; }
@DynamoDBIgnore
public String getSomeProp() { return someProp;}
public void setSomeProp(String someProp) {this.someProp = someProp;}
@DynamoDBVersionAttribute
public Long getVersion() { return version; }
public void setVersion(Long version) { this.version = version;}
}
```
Sie können die `@DynamoDBVersionAttribute`-Anmerkung auf löschbare Typen anwenden, die durch primitive Wrapper-Klassen bereitgestellt wurden, die wiederum einen löschbaren Typ wie `Long` und `Integer` bereitstellen.
Die optimistische Sperre hat folgende Auswirkungen auf diese `DynamoDBMapper`-Methoden:
+ `save` – für ein neues Element weist der `DynamoDBMapper` eine erste Versionsnummer 1 zu. Wenn Sie ein Element abrufen, eine oder mehrere seiner Eigenschaften aktualisieren und versuchen, die Änderungen zu speichern, ist die Speicheroperation nur dann erfolgreich, wenn die clientseitige und die serverseitige Versionsnummer übereinstimmen. Der `DynamoDBMapper` erhöht die Versionsnummer automatisch.
+ `delete` – die `delete`-Methode übernimmt ein Objekt als einen Parameter und der `DynamoDBMapper` führt einen Versionscheck durch, bevor er das Element löscht. Der Versionscheck kann deaktiviert werden, wenn `DynamoDBMapperConfig.SaveBehavior.CLOBBER` in der Anforderung angegeben wird.
Die interne Implementierung der optimistischen Sperre im `DynamoDBMapper` nutzt die von DynamoDB bereitgestellte Unterstützung für bedingtes Aktualisieren und bedingtes Löschen.
+ `transactionWrite` —
+ `Put` – für ein neues Element weist der `DynamoDBMapper` eine erste Versionsnummer 1 zu. Wenn Sie ein Element abrufen, eine oder mehrere seiner Eigenschaften aktualisieren und versuchen, die Änderungen zu speichern, ist die Put-Operation nur dann erfolgreich, wenn die clientseitige und die serverseitige Versionsnummer übereinstimmen. Der `DynamoDBMapper` erhöht die Versionsnummer automatisch.
+ `Update` – für ein neues Element weist der `DynamoDBMapper` eine erste Versionsnummer 1 zu. Wenn Sie ein Element abrufen, eine oder mehrere seiner Eigenschaften aktualisieren und versuchen, die Änderungen zu speichern, ist die Update-Operation nur dann erfolgreich, wenn die clientseitige und die serverseitige Versionsnummer übereinstimmen. Der `DynamoDBMapper` erhöht die Versionsnummer automatisch.
+ `Delete` – `DynamoDBMapper` führt eine Versionsprüfung durch, bevor er das Element löscht. Die Lösch-Operation ist nur dann erfolgreich, wenn die Versionsnummern auf Clientseite und auf Serverseite übereinstimmen.
+ `ConditionCheck` – die `@DynamoDBVersionAttribute`-Anmerkung wird für `ConditionCheck`-Operationen nicht unterstützt. Ein SdkClientException wird ausgelöst, wenn ein `ConditionCheck` Element mit einer Anmerkung versehen ist. `@DynamoDBVersionAttribute`
## Deaktivieren der optimistischen Sperre
(Arrays.asList("Author1", "Author2")));
book.setDimensions(dimType);
DynamoDBMapper mapper = new DynamoDBMapper(client);
mapper.save(book);
Book bookRetrieved = mapper.load(Book.class, 502);
System.out.println("Book info: " + "\n" + bookRetrieved);
bookRetrieved.getDimensions().setHeight("9.0");
bookRetrieved.getDimensions().setLength("12.0");
bookRetrieved.getDimensions().setThickness("2.0");
mapper.save(bookRetrieved);
bookRetrieved = mapper.load(Book.class, 502);
System.out.println("Updated book info: " + "\n" + bookRetrieved);
}
@DynamoDBTable(tableName = "ProductCatalog")
public static class Book {
private int id;
private String title;
private String ISBN;
private Set bookAuthors;
private DimensionType dimensionType;
// Partition key
@DynamoDBHashKey(attributeName = "Id")
public int getId() {
return id;
}
public void setId(int 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 getBookAuthors() {
return bookAuthors;
}
public void setBookAuthors(Set bookAuthors) {
this.bookAuthors = bookAuthors;
}
@DynamoDBTypeConverted(converter = DimensionTypeConverter.class)
@DynamoDBAttribute(attributeName = "Dimensions")
public DimensionType getDimensions() {
return dimensionType;
}
@DynamoDBAttribute(attributeName = "Dimensions")
public void setDimensions(DimensionType dimensionType) {
this.dimensionType = dimensionType;
}
@Override
public String toString() {
return "Book [ISBN=" + ISBN + ", bookAuthors=" + bookAuthors + ", dimensionType= "
+ dimensionType.getHeight() + " X " + dimensionType.getLength() + " X "
+ dimensionType.getThickness()
+ ", Id=" + id + ", Title=" + title + "]";
}
}
static public class DimensionType {
private String length;
private String height;
private String thickness;
public String getLength() {
return length;
}
public void setLength(String length) {
this.length = length;
}
public String getHeight() {
return height;
}
public void setHeight(String height) {
this.height = height;
}
public String getThickness() {
return thickness;
}
public void setThickness(String thickness) {
this.thickness = thickness;
}
}
// Converts the complex type DimensionType to a string and vice-versa.
static public class DimensionTypeConverter implements DynamoDBTypeConverter {
@Override
public String convert(DimensionType object) {
DimensionType itemDimensions = (DimensionType) object;
String dimension = null;
try {
if (itemDimensions != null) {
dimension = String.format("%s x %s x %s", itemDimensions.getLength(), itemDimensions.getHeight(),
itemDimensions.getThickness());
}
} catch (Exception e) {
e.printStackTrace();
}
return dimension;
}
@Override
public DimensionType unconvert(String s) {
DimensionType itemDimension = new DimensionType();
try {
if (s != null && s.length() != 0) {
String[] data = s.split("x");
itemDimension.setLength(data[0].trim());
itemDimension.setHeight(data[1].trim());
itemDimension.setThickness(data[2].trim());
}
} catch (Exception e) {
e.printStackTrace();
}
return itemDimension;
}
}
}
```
# Beispiele für DynamoDBMapper
BookAuthors { get; set; }
[DynamoDBIgnore]
public string CoverPage { get; set; }
}
```
Im vorherigen Beispiel ordnet das Attribut `DynamoDBTable` die Klasse `Book` der Tabelle `ProductCatalog` zu.
Das Object Persistence-Modell unterstützt die explizite und das Standardmapping zwischen Klasseneigenschaften und Tabellenattributen.
+ **Explizites Mapping – **Um eine Eigenschaft einem Primärschlüssel zuzuordnen, müssen Sie die `DynamoDBHashKey`- und `DynamoDBRangeKey`-Attribute des „Object-Persistence“-Modells verwenden. Außerdem gilt für andere als Primärschlüsselattribute, dass Sie das Mapping durch explizites Hinzufügen des Attributs `DynamoDBProperty` definieren müssen, wenn der Name einer Eigenschaft in Ihrer Klasse und des Tabellenattributs, dem Sie diese zuordnen möchten, nicht identisch sind.
Im vorherigen Beispiel werden die Eigenschaft `Id` dem Primärschlüssel mit dem gleichen Namen und die Eigenschaft `BookAuthors` dem Attribut `Authors` in der Tabelle `ProductCatalog` zugeordnet.
+ **Standard-Mapping – **Standardmäßig ordnet das „Object Persistence“-Modell die Klasseneigenschaften den Attributen mit identischem Namen in der Tabelle zu.
Im vorherigen Beispiel werden die Eigenschaften `Title` und `ISBN` den Attributen mit den gleichen Namen in der Tabelle `ProductCatalog` zugeordnet.
Sie müssen nicht jede einzelne Klasseneigenschaft zuordnen. Sie erkennen diese Eigenschaften, indem Sie das `DynamoDBIgnore`-Attribut hinzufügen. Wenn Sie eine `Book`-Instance in die Tabelle hochladen, enthält der `DynamoDBContext` nicht die `CoverPage`-Eigenschaft. Diese Eigenschaft wird auch nicht zurückgegeben, wenn Sie die Book-Instance abrufen.
Sie können Eigenschaften von primitiven .NET-Typen wie „int“ und „string“ zuweisen. Sie können auch beliebige Datentypen zuordnen, solange Sie einen geeigneten Konverter bereitstellen, um diese Datentypen einem DynamoDB-Datentyp zuzuordnen. Weitere Informationen zum Mapping beliebiger Datentypen finden Sie unter [Zuordnen beliebiger Daten mit DynamoDB mithilfe des AWS SDK für .NET Objektpersistenzmodells](DynamoDBContext.ArbitraryDataMapping.md).
Das Object Persistence-Modell unterstützt die optimistische Sperre. Während einer Aktualisierung stellt diese Funktion sicher, dass Sie über die neueste Kopie des zu aktualisierenden Elements verfügen. Weitere Informationen finden Sie unter [Optimistisches Sperren mit DynamoDB und dem AWS SDK für .NET Objektpersistenzmodell](DynamoDBContext.VersionSupport.md).
Weitere Informationen finden Sie in den folgenden Themen.
**Topics**
+ [
## Unterstützte Datentypen
](#DotNetDynamoDBContext.SupportedTypes)
+ [
# DynamoDB-Attribute aus dem Object Persistence-Modell von .NET
](DeclarativeTagsList.md)
+ [
# DBContext Dynamo-Klasse aus dem .NET-Objektpersistenzmodell
](DotNetDynamoDBContext.md)
+ [
# Optimistisches Sperren mit DynamoDB und dem AWS SDK für .NET Objektpersistenzmodell
](DynamoDBContext.VersionSupport.md)
+ [
# Zuordnen beliebiger Daten mit DynamoDB mithilfe des AWS SDK für .NET Objektpersistenzmodells
](DynamoDBContext.ArbitraryDataMapping.md)
## Unterstützte Datentypen
BookAuthors { get; set; }
```
`DynamoDBContext` verwendet diese Mappinginformationen, um beim Speichern von Objektdaten zur entsprechenden Tabelle das Attribut `Authors` zu erstellen.
## Dynamo DBRenamable
(101);
```
**Anmerkung**
Wenn das `Document`-Objekt die `IEnumerable`-Schnittstelle implementiert, können Sie stattdessen die `FromDocuments`-Methode nutzen. Auf diese Weise können Sie alle Klassen-Instances im `Document` durchlaufen.
## FromQuery
/// Shows how to perform high-level CRUD operations on an Amazon DynamoDB
/// table.
///
public class HighLevelItemCrud
{
public static async Task Main()
{
var client = new AmazonDynamoDBClient();
DynamoDBContext context = new DynamoDBContext(client);
await PerformCRUDOperations(context);
}
public static async Task PerformCRUDOperations(IDynamoDBContext context)
{
int bookId = 1001; // Some unique value.
Book myBook = new Book
{
Id = bookId,
Title = "object persistence-AWS SDK for.NET SDK-Book 1001",
Isbn = "111-1111111001",
BookAuthors = new List { "Author 1", "Author 2" },
};
// Save the book to the ProductCatalog table.
await context.SaveAsync(myBook);
// Retrieve the book from the ProductCatalog table.
Book bookRetrieved = await context.LoadAsync(bookId);
// Update some properties.
bookRetrieved.Isbn = "222-2222221001";
// Update existing authors list with the following values.
bookRetrieved.BookAuthors = new List { " Author 1", "Author x" };
await context.SaveAsync(bookRetrieved);
// Retrieve the updated book. This time, add the optional
// ConsistentRead parameter using DynamoDBContextConfig object.
await context.LoadAsync(bookId, new DynamoDBContextConfig
{
ConsistentRead = true,
});
// Delete the book.
await context.DeleteAsync(bookId);
// Try to retrieve deleted book. It should return null.
Book deletedBook = await context.LoadAsync(bookId, new DynamoDBContextConfig
{
ConsistentRead = true,
});
if (deletedBook == null)
{
Console.WriteLine("Book is deleted");
}
}
}
```
## Query
latestReplies = context.Query(replyId, QueryOperator.GreaterThan, twoWeeksAgoDate);
```
Dies gibt eine Sammlung von `Reply`-Objekten zurück.
Die Methode `Query` gibt standardmäßig eine „lazy-loaded“ `IEnumerable`-Sammlung zurück. Sie gibt anfänglich ausschließlich eine Ergebnisseite zurück und führt dann bei Bedarf einen Dienstaufruf für die nächste Seite durch. Um alle übereinstimmenden Elemente zu erhalten, müssen Sie lediglich die `IEnumerable`-Sammlung durchlaufen.
Wenn die Tabelle über einen einfachen Primärschlüssel (Partitionsschlüssel) verfügt, können Sie die Methode `Query` nicht verwenden. Stattdessen können Sie die Methode `Load` verwenden und den Partitionsschlüssel bereitstellen, um das Element abzurufen.
**Anmerkung**
Um diese Operation im Hintergrund auszuführen, nutzen Sie stattdessen die `QueryAsync`-Methode.
## Save
itemsWithWrongPrice = context.Scan(
new ScanCondition("Price", ScanOperator.LessThan, price),
new ScanCondition("ProductCategory", ScanOperator.Equal, "Book")
);
```
Die Methode `Scan` gibt standardmäßig eine „lazy-loaded“ `IEnumerable`-Sammlung zurück. Sie gibt anfänglich ausschließlich eine Ergebnisseite zurück und führt dann bei Bedarf einen Dienstaufruf für die nächste Seite durch. Um alle übereinstimmenden Elemente zu erhalten, müssen Sie lediglich die `IEnumerable`-Sammlung durchlaufen.
Aus Leistungsgründen sollten Sie Ihre Tabellen abfragen und einen Tabellen-Scan vermeiden.
**Anmerkung**
Um diese Operation im Hintergrund auszuführen, nutzen Sie stattdessen die `ScanAsync`-Methode.
## ToDocument
(101); // Retrieve a forum by primary key.
Document doc = context.ToDocument(forum101);
```
## Optionale Parameter für Dynamo angeben DBContext
(productId,new DynamoDBContextConfig{ ConsistentRead = true, SkipVersionCheck = true });
```
In diesem Fall berücksichtigt `DynamoDBContext` diese Parameter ausschließlich beim Senden der `Get`-Anforderung.
# Optimistisches Sperren mit DynamoDB und dem AWS SDK für .NET Objektpersistenzmodell
BookAuthors { get; set; }
[DynamoDBVersion]
public int? VersionNumber { get; set; }
}
```
**Anmerkung**
Sie können das `DynamoDBVersion`-Attribut ausschließlich auf einen löschbaren numerischen primitiven Typen anwenden (z. B. `int?`).
Die optimistische Sperre hat folgende Auswirkungen auf diese `DynamoDBContext`-Operationen:
+ Für ein neues Element weist `DynamoDBContext` die Erstversionsnummer 0 zu. Wenn Sie ein vorhandenes Element abrufen, eine oder mehrere von dessen Eigenschaften aktualisieren und versuchen, die Änderungen zu speichern, wird die Speicheroperation nur dann erfolgreich ausgeführt, wenn die client- und serverseitige Versionsnummer übereinstimmen. `DynamoDBContext` erhöht die Versionsnummer inkrementell. Sie müssen die Versionsnummer nicht festlegen.
+ Die Methode `Delete` stellt Überladungen bereit, die entweder einen Primärschlüsselwert oder ein Objekt als Parameter aufnehmen können, wie im folgenden C\$1-Codebeispiel gezeigt.
**Example**
```
DynamoDBContext context = new DynamoDBContext(client);
...
// Load a book.
Book book = context.Load(111);
// Do other operations.
// Delete 1 - Pass in the book object.
context.Delete(book);
// Delete 2 - Pass in the Id (primary key)
context.Delete(222);
```
Wenn Sie ein Objekt als Parameter bereitstellen, ist der Löschvorgang nur dann erfolgreich, wenn die Objektversion mit der entsprechenden serverseitigen Elementversion übereinstimmt. Wenn Sie jedoch einen Primärschlüsselwert als Parameter bereitstellen, erkennt `DynamoDBContext` keine Versionsnummern und löscht das Element, ohne die Version zu prüfen.
Beachten Sie, dass die interne Implementierung von optimistischen Sperren in dem Code des Object-Persistence-Modells bedingte Aktualisierungen und bedingte Löschungs-API-Aktionen in DynamoDB verwendet.
## Deaktivieren der optimistischen Sperre
(111);
...
// Delete the book.
context.Delete(book, new DynamoDBContextConfig { SkipVersionCheck = true });
```
# Zuordnen beliebiger Daten mit DynamoDB mithilfe des AWS SDK für .NET Objektpersistenzmodells
{ "Author 1", "Author 2" },
Dimensions = myBookDimensions
};
context.Save(myBook);
// 2. Retrieve the book.
Book bookRetrieved = context.Load(501);
// 3. Update property (book dimensions).
bookRetrieved.Dimensions.Height += 1;
bookRetrieved.Dimensions.Length += 1;
bookRetrieved.Dimensions.Thickness += 0.2M;
// Update the book.
context.Save(bookRetrieved);
Console.WriteLine("To continue, press Enter");
Console.ReadLine();
}
catch (AmazonDynamoDBException e) { Console.WriteLine(e.Message); }
catch (AmazonServiceException e) { Console.WriteLine(e.Message); }
catch (Exception e) { Console.WriteLine(e.Message); }
}
}
[DynamoDBTable("ProductCatalog")]
public class Book
{
[DynamoDBHashKey] //Partition key
public int Id
{
get; set;
}
[DynamoDBProperty]
public string Title
{
get; set;
}
[DynamoDBProperty]
public string ISBN
{
get; set;
}
// Multi-valued (set type) attribute.
[DynamoDBProperty("Authors")]
public List BookAuthors
{
get; set;
}
// Arbitrary type, with a converter to map it to DynamoDB type.
[DynamoDBProperty(typeof(DimensionTypeConverter))]
public DimensionType Dimensions
{
get; set;
}
}
public class DimensionType
{
public decimal Length
{
get; set;
}
public decimal Height
{
get; set;
}
public decimal Thickness
{
get; set;
}
}
// Converts the complex type DimensionType to string and vice-versa.
public class DimensionTypeConverter : IPropertyConverter
{
public DynamoDBEntry ToEntry(object value)
{
DimensionType bookDimensions = value as DimensionType;
if (bookDimensions == null) throw new ArgumentOutOfRangeException();
string data = string.Format("{1}{0}{2}{0}{3}", " x ",
bookDimensions.Length, bookDimensions.Height, bookDimensions.Thickness);
DynamoDBEntry entry = new Primitive
{
Value = data
};
return entry;
}
public object FromEntry(DynamoDBEntry entry)
{
Primitive primitive = entry as Primitive;
if (primitive == null || !(primitive.Value is String) || string.IsNullOrEmpty((string)primitive.Value))
throw new ArgumentOutOfRangeException();
string[] data = ((string)(primitive.Value)).Split(new string[] { " x " }, StringSplitOptions.None);
if (data.Length != 3) throw new ArgumentOutOfRangeException();
DimensionType complexData = new DimensionType
{
Length = Convert.ToDecimal(data[0]),
Height = Convert.ToDecimal(data[1]),
Thickness = Convert.ToDecimal(data[2])
};
return complexData;
}
}
}
```
# Ausführen der Codebeispiele in diesem Entwicklerhandbuch
```
Zur Laufzeit verwendet das `default` Programm die im `AWSProfileName` Eintrag angegebenen AWS Anmeldeinformationen. Die AWS Anmeldeinformationen selbst werden in verschlüsselter Form im SDK-Speicher gespeichert. Das Toolkit for Visual Studio bietet eine grafische Benutzeroberfläche, um Ihre Anmeldeinformationen vollständig über Visual Studio zu verwalten. Weitere Informationen finden Sie unter [Anmeldeinformationen angeben](https://docs.aws.amazon.com/AWSToolkitVS/latest/UserGuide/tkv_setup.html#creds) im *AWS Toolkit for Visual Studio -Benutzerleitfaden*.
**Anmerkung**
Standardmäßig greifen die Codebeispiele auf DynamoDB in der Region USA West (Oregon) auf. Sie können die Region ändern, indem Sie den `AWSRegion`-Eintrag in der Datei App.config ändern. Sie können `AWSRegion` auf jede Region festlegen, in der DynamoDB verfügbar ist. Die vollständige Liste finden Sie unter [AWS -Regionen und -Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html#ddb_region) in der *Allgemeine Amazon Web Services-Referenz*.
## .NET: AWS Region und Endpunkt festlegen
.;
Accept-Encoding: identity
Content-Length:
User-Agent:
Content-Type: application/x-amz-json-1.0
Authorization: AWS4-HMAC-SHA256 Credential=, SignedHeaders=, Signature=
X-Amz-Date:
X-Amz-Target: DynamoDB_20120810.GetItem
{
"TableName": "Pets",
"Key": {
"AnimalType": {"S": "Dog"},
"Name": {"S": "Fido"}
}
}
```
Beachten Sie bei dieser Anforderung Folgendes:
+ Der Header `Authorization` enthält Informationen, die DynamoDB benötigt, um die Anforderung zu authentifizieren. Weitere Informationen finden Sie unter [Signieren von AWS API-Anfragen](https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html) und [Signiervorgang für Signature Version 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) in der *Allgemeine Amazon Web Services-Referenz*.
+ Der Header `X-Amz-Target` enthält den Namen einer DynamoDB-Operation: `GetItem`. (Ebenfalls enthalten ist die Version der API auf niedriger Ebene, in diesem Fall `20120810`.)
+ Die Nutzlast (der Text) der Anforderung enthält die Parameter für die Operation im JSON-Format. Für die Operation `GetItem` lauten die Parameter `TableName` und `Key`.
## Reaktionsformat
x-amz-crc32:
Content-Type: application/x-amz-json-1.0
Content-Length:
Date:
{
"Item": {
"Age": {"N": "8"},
"Colors": {
"L": [
{"S": "White"},
{"S": "Brown"},
{"S": "Black"}
]
},
"Name": {"S": "Fido"},
"Vaccinations": {
"M": {
"Rabies": {
"L": [
{"S": "2009-03-17"},
{"S": "2011-09-21"},
{"S": "2014-07-08"}
]
},
"Distemper": {"S": "2015-10-13"}
}
},
"Breed": {"S": "Beagle"},
"AnimalType": {"S": "Dog"}
}
}
```
Zu diesem Zeitpunkt sendet das AWS SDK die Antwortdaten zur weiteren Verarbeitung an Ihre Anwendung zurück.
**Anmerkung**
Wenn DynamoDB eine Anforderung nicht verarbeiten kann, gibt der Service einen HTTP-Fehlercode mit einer entsprechenden Meldung zurück. Das AWS -SDK überträgt diese an Ihre Anwendung in Form von Ausnahmen. Weitere Informationen finden Sie unter [Fehlerbehandlung mit DynamoDB](Programming.Errors.md).
## Datentypbeschreibungen
const results = await waitUntilTableExists({client: client, maxWaitTime: 180}, {TableName: "products"});
if (results.state == 'SUCCESS') {
return results.reason.Table
}
console.error(`${results.state} ${results.reason}`);
```
Die Funktion `waitUntilTableExists` gibt die Kontrolle erst dann zurück, wenn ein `describe-table`-Befehl erfolgreich ausgeführt werden kann, der den Tabellenstatus als **ACTIVE** bestätigt. Dadurch können Sie `waitUntilTableExists` nicht nur verwenden, um auf die vollständige Erstellung einer Tabelle zu warten, sondern auch auf Änderungen wie das Hinzufügen eines GSI-Index, dessen Anwendung einige Zeit in Anspruch nehmen kann, bevor die Tabelle wieder den Status **ACTIVE** erreicht.
## Fehlerbehandlung
4.0.0
org.example
getstarted
1.0-SNAPSHOT
jar
UTF-8
1.8
1.8
3.2.1
3.6.1
1.6.0
2.22.0 <-------- SDK version picked up from archetype version.
1.7.28
5.8.1
software.amazon.awssdk
bom
${aws.java.sdk.version}
pom
import
software.amazon.awssdk
dynamodb <-------- DynamoDB dependency
software.amazon.awssdk
netty-nio-client
software.amazon.awssdk
apache-client
software.amazon.awssdk
sso <-------- Required for identity center authentication.
software.amazon.awssdk
ssooidc <-------- Required for identity center authentication.
software.amazon.awssdk
apache-client <-------- HTTP client specified.
commons-logging
commons-logging
org.slf4j
slf4j-api
${slf4j.version}
org.slf4j
slf4j-simple
${slf4j.version}
org.slf4j
jcl-over-slf4j
${slf4j.version}
org.junit.jupiter
junit-jupiter
${junit5.version}
test
org.apache.maven.plugins
maven-compiler-plugin
${maven.compiler.plugin.version}
```
### Schritt 3: Schreiben des Codes
DYNAMODB_TABLE = ENHANCED_DYNAMODB_CLIENT.table("YourTableName", TableSchema.fromBean(YourItem.class));
private static final Logger LOGGER = LoggerFactory.getLogger(PutItem.class);
private void putItem() {
PutItemEnhancedResponse response = DYNAMODB_TABLE.putItemWithResponse(PutItemEnhancedRequest.builder(YourItem.class)
.item(new YourItem("123", "cart#123", "YourItemData", 500))
.returnConsumedCapacity(ReturnConsumedCapacity.TOTAL)
.build());
LOGGER.info("PutItem call consumed [" + response.consumedCapacity().capacityUnits() + "] Write Capacity Unites (WCU)");
}
@DynamoDbBean
public static class YourItem {
public YourItem() {}
public YourItem(String pk, String sk, String itemData, int inventory) {
this.pk = pk;
this.sk = sk;
this.itemData = itemData;
this.inventory = inventory;
}
private String pk;
private String sk;
private String itemData;
private int inventory;
@DynamoDbPartitionKey
public void setPk(String pk) {
this.pk = pk;
}
public String getPk() {
return pk;
}
@DynamoDbSortKey
public void setSk(String sk) {
this.sk = sk;
}
public String getSk() {
return sk;
}
public void setItemData(String itemData) {
this.itemData = itemData;
}
public String getItemData() {
return itemData;
}
public void setInventory(int inventory) {
this.inventory = inventory;
}
public int getInventory() {
return inventory;
}
}
}
```
Die AWS SDK für Java Version 1.x hat ihre eigene High-Level-Schnittstelle, die oft mit ihrer Hauptklasse `DynamoDBMapper` bezeichnet wird. Das AWS SDK for Java 2.x wird in einem separaten Paket (und einem Maven-Artefakt) mit dem Namen veröffentlicht. `software.amazon.awssdk.enhanced.dynamodb` Das Java SDK 2.x wird oft über seine Hauptklasse `DynamoDbEnhancedClient` referenziert.
#### High-Level-Schnittstelle mit unveränderlichen Datenklassen
DYNAMODB_TABLE = ENHANCED_DYNAMODB_CLIENT.table("YourTableName", TableSchema.fromImmutableClass(YourImmutableItem.class));
private static final Logger LOGGER = LoggerFactory.getLogger(DynamoDbEnhancedClientImmutablePutItem.class);
private void putItem() {
PutItemEnhancedResponse response = DYNAMODB_TABLE.putItemWithResponse(PutItemEnhancedRequest.builder(YourImmutableItem.class)
.item(YourImmutableItem.builder()
.pk("123")
.sk("cart#123")
.itemData("YourItemData")
.inventory(500)
.build())
.returnConsumedCapacity(ReturnConsumedCapacity.TOTAL)
.build());
LOGGER.info("PutItem call consumed [" + response.consumedCapacity().capacityUnits() + "] Write Capacity Unites (WCU)");
}
}
```
Im folgenden Beispiel wird die unveränderliche Datenklasse gezeigt.
```
@DynamoDbImmutable(builder = YourImmutableItem.YourImmutableItemBuilder.class)
class YourImmutableItem {
private final String pk;
private final String sk;
private final String itemData;
private final int inventory;
public YourImmutableItem(YourImmutableItemBuilder builder) {
this.pk = builder.pk;
this.sk = builder.sk;
this.itemData = builder.itemData;
this.inventory = builder.inventory;
}
public static YourImmutableItemBuilder builder() { return new YourImmutableItemBuilder(); }
@DynamoDbPartitionKey
public String getPk() {
return pk;
}
@DynamoDbSortKey
public String getSk() {
return sk;
}
public String getItemData() {
return itemData;
}
public int getInventory() {
return inventory;
}
static final class YourImmutableItemBuilder {
private String pk;
private String sk;
private String itemData;
private int inventory;
private YourImmutableItemBuilder() {}
public YourImmutableItemBuilder pk(String pk) { this.pk = pk; return this; }
public YourImmutableItemBuilder sk(String sk) { this.sk = sk; return this; }
public YourImmutableItemBuilder itemData(String itemData) { this.itemData = itemData; return this; }
public YourImmutableItemBuilder inventory(int inventory) { this.inventory = inventory; return this; }
public YourImmutableItem build() { return new YourImmutableItem(this); }
}
}
```
#### High-Level-Schnittstelle mit unveränderlichen Datenklassen und externen Bibliotheken zur Generierung von Boilerplate-Code
DYNAMODB_TABLE = ENHANCED_DYNAMODB_CLIENT.table("YourTableName", TableSchema.fromImmutableClass(YourImmutableLombokItem.class));
private static final Logger LOGGER = LoggerFactory.getLogger(DynamoDbEnhancedClientImmutableLombokPutItem.class);
private void putItem() {
PutItemEnhancedResponse response = DYNAMODB_TABLE.putItemWithResponse(PutItemEnhancedRequest.builder(YourImmutableLombokItem.class)
.item(YourImmutableLombokItem.builder()
.pk("123")
.sk("cart#123")
.itemData("YourItemData")
.inventory(500)
.build())
.returnConsumedCapacity(ReturnConsumedCapacity.TOTAL)
.build());
LOGGER.info("PutItem call consumed [" + response.consumedCapacity().capacityUnits() + "] Write Capacity Unites (WCU)");
}
}
```
Das folgende Beispiel zeigt das unveränderliche Datenobjekt der unveränderlichen Datenklasse.
```
import lombok.*;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.*;
@Builder
@DynamoDbImmutable(builder = YourImmutableLombokItem.YourImmutableLombokItemBuilder.class)
@Value
public class YourImmutableLombokItem {
@Getter(onMethod_=@DynamoDbPartitionKey)
String pk;
@Getter(onMethod_=@DynamoDbSortKey)
String sk;
String itemData;
int inventory;
}
```
Die `YourImmutableLombokItem` Klasse verwendet die folgenden Anmerkungen, die Project Lombok und das SDK bereitstellen: AWS
+ [@Builder](https://projectlombok.org/features/Builder) — Produziert einen komplexen Builder APIs für Datenklassen, den Project Lombok bereitstellt.
+ [@ DynamoDbImmutable](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/mapper/annotations/DynamoDbImmutable.html) — Identifiziert die `DynamoDbImmutable` Klasse als eine vom SDK DynamoDB DynamoDB-Annotation für zuordenbare Entitäten. AWS
+ [@Value](https://projectlombok.org/features/Value) – Die unveränderliche Variante von `@Data`. Standardmäßig sind alle Felder privat und endgültig, und es werden keine Setter generiert. Project Lombok stellt diese Annotation zur Verfügung.
### Dokumentschnittstelle
DYNAMODB_TABLE =
ENHANCED_DYNAMODB_CLIENT.table("YourTableName", TableSchema.documentSchemaBuilder()
.addIndexPartitionKey(TableMetadata.primaryIndexName(),"pk", AttributeValueType.S)
.addIndexSortKey(TableMetadata.primaryIndexName(), "sk", AttributeValueType.S)
.attributeConverterProviders(AttributeConverterProvider.defaultProvider())
.build());
private static final Logger LOGGER = LoggerFactory.getLogger(DynamoDbEnhancedDocumentClientPutItem.class);
private void putItem() {
PutItemEnhancedResponse response = DYNAMODB_TABLE.putItemWithResponse(
PutItemEnhancedRequest.builder(EnhancedDocument.class)
.item(
EnhancedDocument.builder()
.attributeConverterProviders(AttributeConverterProvider.defaultProvider())
.putString("pk", "123")
.putString("sk", "cart#123")
.putString("item_data", "YourItemData")
.putNumber("inventory", 500)
.build())
.returnConsumedCapacity(ReturnConsumedCapacity.TOTAL)
.build());
LOGGER.info("PutItem call consumed [" + response.consumedCapacity().capacityUnits() + "] Write Capacity Unites (WCU)");
}
}
```
Um JSON-Dokumente in native Amazon-DynamoDB-Datentypen zu konvertieren und umgekehrt, können Sie die folgenden Hilfsmethoden verwenden:
+ [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/document/EnhancedDocument.html#fromJson(java.lang.String)](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/document/EnhancedDocument.html#fromJson(java.lang.String))— Erzeugt eine neue EnhancedDocument Instanz aus einer JSON-Zeichenfolge.
+ [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/document/EnhancedDocument.html#toJson()](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/document/EnhancedDocument.html#toJson()) – Erstellt eine JSON-Zeichenfolgendarstellung des Dokuments, die Sie in Ihrer Anwendung wie jedes andere JSON-Objekt verwenden können.
### Vergleichen von Schnittstellen anhand eines `Query`-Beispiels
DYNAMODB_TABLE =
ENHANCED_DYNAMODB_CLIENT.table("YourTableName", TableSchema.documentSchemaBuilder()
.addIndexPartitionKey(TableMetadata.primaryIndexName(),"pk", AttributeValueType.S)
.addIndexSortKey(TableMetadata.primaryIndexName(), "sk", AttributeValueType.S)
.attributeConverterProviders(AttributeConverterProvider.defaultProvider())
.build());
private static final Logger LOGGER = LoggerFactory.getLogger(DynamoDbEnhancedDocumentClientQuery.class);
private void query() {
PageIterable response = DYNAMODB_TABLE.query(QueryEnhancedRequest.builder()
.filterExpression(Expression.builder()
.expression("#name = :name_val")
.expressionNames(Map.of("#name", "name"))
.expressionValues(Map.of(":name_val", AttributeValue.fromS("SomeName")))
.build())
.limit(100)
.queryConditional(QueryConditional.sortBeginsWith(Key.builder()
.partitionValue("id#1")
.sortValue("cart#")
.build()))
.scanIndexForward(false)
.build());
LOGGER.info("nr of items: " + response.items().stream().count());
LOGGER.info("First item pk: " + response.items().iterator().next().getString("pk"));
LOGGER.info("First item sk: " + response.items().iterator().next().getString("sk"));
}
}
```
**Example `Query` unter Verwendung der High-Level-Schnittstelle**
Im folgenden Beispiel wird eine Abfrage auf einer Tabelle mit dem Namen `YourTableName` unter Verwendung der erweiterten DynamoDB-Client-API durchgeführt.
```
import org.slf4j.*;
import software.amazon.awssdk.enhanced.dynamodb.*;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.*;
import software.amazon.awssdk.enhanced.dynamodb.model.*;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
import java.util.Map;
public class DynamoDbEnhancedClientQuery {
private static final DynamoDbEnhancedClient ENHANCED_DYNAMODB_CLIENT = DynamoDbEnhancedClient.builder().build();
private static final DynamoDbTable DYNAMODB_TABLE = ENHANCED_DYNAMODB_CLIENT.table("YourTableName", TableSchema.fromBean(DynamoDbEnhancedClientQuery.YourItem.class));
private static final Logger LOGGER = LoggerFactory.getLogger(DynamoDbEnhancedClientQuery.class);
private void query() {
PageIterable response = DYNAMODB_TABLE.query(QueryEnhancedRequest.builder()
.filterExpression(Expression.builder()
.expression("#name = :name_val")
.expressionNames(Map.of("#name", "name"))
.expressionValues(Map.of(":name_val", AttributeValue.fromS("SomeName")))
.build())
.limit(100)
.queryConditional(QueryConditional.sortBeginsWith(Key.builder()
.partitionValue("id#1")
.sortValue("cart#")
.build()))
.scanIndexForward(false)
.build());
LOGGER.info("nr of items: " + response.items().stream().count());
LOGGER.info("First item pk: " + response.items().iterator().next().getPk());
LOGGER.info("First item sk: " + response.items().iterator().next().getSk());
}
@DynamoDbBean
public static class YourItem {
public YourItem() {}
public YourItem(String pk, String sk, String name) {
this.pk = pk;
this.sk = sk;
this.name = name;
}
private String pk;
private String sk;
private String name;
@DynamoDbPartitionKey
public void setPk(String pk) {
this.pk = pk;
}
public String getPk() {
return pk;
}
@DynamoDbSortKey
public void setSk(String sk) {
this.sk = sk;
}
public String getSk() {
return sk;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
}
```
**High-Level-Schnittstelle mit unveränderlichen Datenklassen**
Wenn Sie eine `Query` mit unveränderlichen Datenklassen durchführen, entspricht der Code dem Beispiel für die High-Level-Schnittstelle; die Konstruktion der Entitätsklasse `YourItem` oder `YourImmutableItem` ist jedoch anders. Weitere Informationen finden Sie im [PutItem](#HighLevelImmutableDataClassEg)Beispiel.
**High-Level-Schnittstelle mit unveränderlichen Datenklassen und externen Bibliotheken zur Generierung von Boilerplate-Code**
Wenn Sie eine `Query` mit unveränderlichen Datenklassen durchführen, entspricht der Code dem Beispiel für die High-Level-Schnittstelle; die Konstruktion der Entitätsklasse `YourItem` oder `YourImmutableLombokItem` ist jedoch anders. Weitere Informationen finden Sie im [PutItem](#HighLevelImmutableDataClassEg)Beispiel.
## Weitere Codebeispiele
```
### AWS ID-Protokollierung anfordern
```
Hier finden Sie ein Beispiel für die Protokollausgabe:
```
2022-09-23 16:02:08 [main] DEBUG software.amazon.awssdk.request:85 - Sending Request: DefaultSdkHttpFullRequest(httpMethod=POST, protocol=https, host=dynamodb.us-east-1.amazonaws.com, encodedPath=/, headers=[amz-sdk-invocation-id, Content-Length, Content-Type, User-Agent, X-Amz-Target], queryParameters=[])
2022-09-23 16:02:08 [main] DEBUG software.amazon.awssdk.request:85 - Received successful response: 200, Request ID: QS9DUMME2NHEDH8TGT9N5V53OJVV4KQNSO5AEMVJF66Q9ASUAAJG, Extended Request ID: not available
```
## Paginierung