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.
# Arbeiten mit Elementen: Java
Sie können die AWS SDK für Java Dokument-API verwenden, um typische Erstellungs-, Lese-, Aktualisierungs- und Löschvorgänge (CRUD) für Amazon DynamoDB DynamoDB-Elemente in einer Tabelle durchzuführen.
**Anmerkung**
Das SDK für Java stellt auch ein Objektpersistenzmodell bereit, mit dem Sie Ihre clientseitigen Klassen DynamoDB-Tabellen zuordnen können. Mit diesem Ansatz können Sie die Codemenge, die Sie schreiben müssen, verringern. Weitere Informationen finden Sie unter [Java 1.x: Dynamo DBMapper](DynamoDBMapper.md).
Dieser Abschnitt enthält Java-Beispiele zur Durchführung verschiedener Java-Dokument-API-Elementaktionen und mehrere vollständige Arbeitsbeispiele.
**Topics**
+ [Einfügen eines Elements](#PutDocumentAPIJava)
+ [Abrufen eines Elements](#JavaDocumentAPIGetItem)
+ [Batch Write: Einfügen und Löschen mehrerer Elemente](#BatchWriteDocumentAPIJava)
+ [Batch Get: Abrufen mehrerer Elemente](#JavaDocumentAPIBatchGetItem)
+ [Aktualisieren eines Elements](#JavaDocumentAPIItemUpdate)
+ [Löschen eines Elements](#DeleteMidLevelJava)
+ [Beispiel: CRUD-Operationen mit der AWS SDK für Java Dokument-API](JavaDocumentAPICRUDExample.md)
+ [Beispiel: Batch-Operationen mithilfe der AWS SDK für Java Dokument-API](batch-operation-document-api-java.md)
+ [Beispiel: Umgang mit binären Typattributen mithilfe der AWS SDK für Java Dokument-API](JavaDocumentAPIBinaryTypeExample.md)
## Einfügen eines Elements
Die `putItem`-Methode speichert ein Element in einer Tabelle. Wenn das Element bereits vorhanden ist, wird das ganze Element ersetzt. Anstatt das gesamte Element zu ersetzen und nur spezifische Attribute zu aktualisieren, können Sie die Methode `updateItem` verwenden. Weitere Informationen finden Sie unter [Aktualisieren eines Elements](#JavaDocumentAPIItemUpdate).
------
#### [ Java v2 ]
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
import software.amazon.awssdk.services.dynamodb.model.PutItemRequest;
import software.amazon.awssdk.services.dynamodb.model.PutItemResponse;
import software.amazon.awssdk.services.dynamodb.model.ResourceNotFoundException;
import java.util.HashMap;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*
* To place items into an Amazon DynamoDB table using the AWS SDK for Java V2,
* its better practice to use the
* Enhanced Client. See the EnhancedPutItem example.
*/
public class PutItem {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
tableName - The Amazon DynamoDB table in which an item is placed (for example, Music3).
key - The key used in the Amazon DynamoDB table (for example, Artist).
keyval - The key value that represents the item to get (for example, Famous Band).
albumTitle - The Album title (for example, AlbumTitle).
AlbumTitleValue - The name of the album (for example, Songs About Life ).
Awards - The awards column (for example, Awards).
AwardVal - The value of the awards (for example, 10).
SongTitle - The song title (for example, SongTitle).
SongTitleVal - The value of the song title (for example, Happy Day).
**Warning** This program will place an item that you specify into a table!
""";
if (args.length != 9) {
System.out.println(usage);
System.exit(1);
}
String tableName = args[0];
String key = args[1];
String keyVal = args[2];
String albumTitle = args[3];
String albumTitleValue = args[4];
String awards = args[5];
String awardVal = args[6];
String songTitle = args[7];
String songTitleVal = args[8];
Region region = Region.US_EAST_1;
DynamoDbClient ddb = DynamoDbClient.builder()
.region(region)
.build();
putItemInTable(ddb, tableName, key, keyVal, albumTitle, albumTitleValue, awards, awardVal, songTitle,
songTitleVal);
System.out.println("Done!");
ddb.close();
}
public static void putItemInTable(DynamoDbClient ddb,
String tableName,
String key,
String keyVal,
String albumTitle,
String albumTitleValue,
String awards,
String awardVal,
String songTitle,
String songTitleVal) {
HashMap itemValues = new HashMap<>();
itemValues.put(key, AttributeValue.builder().s(keyVal).build());
itemValues.put(songTitle, AttributeValue.builder().s(songTitleVal).build());
itemValues.put(albumTitle, AttributeValue.builder().s(albumTitleValue).build());
itemValues.put(awards, AttributeValue.builder().s(awardVal).build());
PutItemRequest request = PutItemRequest.builder()
.tableName(tableName)
.item(itemValues)
.build();
try {
PutItemResponse response = ddb.putItem(request);
System.out.println(tableName + " was successfully updated. The request id is "
+ response.responseMetadata().requestId());
} catch (ResourceNotFoundException e) {
System.err.format("Error: The Amazon DynamoDB table \"%s\" can't be found.\n", tableName);
System.err.println("Be sure that it exists and that you've typed its name correctly!");
System.exit(1);
} catch (DynamoDbException e) {
System.err.println(e.getMessage());
System.exit(1);
}
}
}
```
------
#### [ Java v1 ]
Dazu gehen Sie wie folgt vor:
1. Erstellen Sie eine Instance der `DynamoDB`-Klasse.
1. Erstellen Sie eine Instance der `Table`-Klasse, um die Tabelle zu repräsentieren, mit der Sie arbeiten möchten.
1. Erstellen Sie eine Instance der `Item`-Klasse, um das neue Element zu repräsentieren. Sie müssen den Primärschlüssel und die Attribute für das neue Element angeben.
1. Rufen Sie die `putItem`-Methode des `Table`-Objekts auf, das das `Item` verwendet, das Sie im vorangegangenen Schritt erstellt haben.
Im folgenden Java-Codebeispiel werden die vorherigen Aufgaben veranschaulicht. Der Code schreibt ein neues Element in die `ProductCatalog`-Tabelle.
**Example**
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB dynamoDB = new DynamoDB(client);
Table table = dynamoDB.getTable("ProductCatalog");
// Build a list of related items
List relatedItems = new ArrayList();
relatedItems.add(341);
relatedItems.add(472);
relatedItems.add(649);
//Build a map of product pictures
Map pictures = new HashMap();
pictures.put("FrontView", "http://example.com/products/123_front.jpg");
pictures.put("RearView", "http://example.com/products/123_rear.jpg");
pictures.put("SideView", "http://example.com/products/123_left_side.jpg");
//Build a map of product reviews
Map> reviews = new HashMap>();
List fiveStarReviews = new ArrayList();
fiveStarReviews.add("Excellent! Can't recommend it highly enough! Buy it!");
fiveStarReviews.add("Do yourself a favor and buy this");
reviews.put("FiveStar", fiveStarReviews);
List oneStarReviews = new ArrayList();
oneStarReviews.add("Terrible product! Do not buy this.");
reviews.put("OneStar", oneStarReviews);
// Build the item
Item item = new Item()
.withPrimaryKey("Id", 123)
.withString("Title", "Bicycle 123")
.withString("Description", "123 description")
.withString("BicycleType", "Hybrid")
.withString("Brand", "Brand-Company C")
.withNumber("Price", 500)
.withStringSet("Color", new HashSet(Arrays.asList("Red", "Black")))
.withString("ProductCategory", "Bicycle")
.withBoolean("InStock", true)
.withNull("QuantityOnHand")
.withList("RelatedItems", relatedItems)
.withMap("Pictures", pictures)
.withMap("Reviews", reviews);
// Write the item to the table
PutItemOutcome outcome = table.putItem(item);
```
Im vorangegangenen Beispiel verfügt das Element über Attribute, die skalar sind (`String`, `Number`, `Boolean`, `Null`), Sätze (`String Set`) sowie Dokumenttypen (`List`, `Map`).
------
### Angeben eines optionalen Parameters
Neben den erforderlichen Parametern können Sie auch optionale Parameter für die `putItem`-Methode angeben. Zum Beispiel verwendet das folgende Java-Codebeispiel einen optionalen Parameter, um eine Bedingung für das Hochladen des Elements anzugeben. Wenn die von Ihnen angegebene Bedingung nicht erfüllt ist, wird eine ausgelöst. AWS SDK für Java `ConditionalCheckFailedException` Das Codebeispiel gibt die folgenden optionalen Parameter in der `putItem`-Methode an:
+ Ein `ConditionExpression`, der die Bedingungen für die Anforderung definiert. In dem Codebeispiel ist die Bedingung definiert, zu der das vorhandene Element mit demselben Primärschlüssel nur dann ersetzt wird, wenn es über ein ISBN-Attribut verfügt, das mit einem bestimmten Wert übereinstimmt.
+ Eine Zuordnung für `ExpressionAttributeValues`, die in der Bedingung verwendet wird. In diesem Fall ist nur eine Ersetzung erforderlich: Der Platzhalter `:val` im Bedingungsausdruck wird zur Laufzeit durch den tatsächlichen zu prüfenden ISBN-Wert ersetzt.
Im folgenden Beispiel wird ein neues Buchelement mit diesen optionalen Parameter hinzugefügt.
**Example**
```
Item item = new Item()
.withPrimaryKey("Id", 104)
.withString("Title", "Book 104 Title")
.withString("ISBN", "444-4444444444")
.withNumber("Price", 20)
.withStringSet("Authors",
new HashSet(Arrays.asList("Author1", "Author2")));
Map expressionAttributeValues = new HashMap();
expressionAttributeValues.put(":val", "444-4444444444");
PutItemOutcome outcome = table.putItem(
item,
"ISBN = :val", // ConditionExpression parameter
null, // ExpressionAttributeNames parameter - we're not using it for this example
expressionAttributeValues);
```
### PutItem und JSON-Dokumente
Sie können ein JSON-Dokument in einer DynamoDB-Tabelle als Attribut speichern. Verwenden Sie dazu die `withJSON`-Methode `Item`. Diese Methode analysiert das JSON-Dokument und ordnet jedes Element einem nativen DynamoDB-Datentyp zu.
Angenommen, Sie möchten das folgende JSON-Dokument speichern, welches Anbieter enthält, die Bestellungen für ein bestimmtes Produkt erfüllen können.
**Example**
```
{
"V01": {
"Name": "Acme Books",
"Offices": [ "Seattle" ]
},
"V02": {
"Name": "New Publishers, Inc.",
"Offices": ["London", "New York"
]
},
"V03": {
"Name": "Better Buy Books",
"Offices": [ "Tokyo", "Los Angeles", "Sydney"
]
}
}
```
Sie können die `withJSON`-Methode verwenden, um es in der `ProductCatalog`-Tabelle in einem `Map`´-Attribut mit dem Namen `VendorInfo` zu speichern. Das folgende Java-Codebeispiel veranschaulicht dies.
```
// Convert the document into a String. Must escape all double-quotes.
String vendorDocument = "{"
+ " \"V01\": {"
+ " \"Name\": \"Acme Books\","
+ " \"Offices\": [ \"Seattle\" ]"
+ " },"
+ " \"V02\": {"
+ " \"Name\": \"New Publishers, Inc.\","
+ " \"Offices\": [ \"London\", \"New York\"" + "]" + "},"
+ " \"V03\": {"
+ " \"Name\": \"Better Buy Books\","
+ "\"Offices\": [ \"Tokyo\", \"Los Angeles\", \"Sydney\""
+ " ]"
+ " }"
+ " }";
Item item = new Item()
.withPrimaryKey("Id", 210)
.withString("Title", "Book 210 Title")
.withString("ISBN", "210-2102102102")
.withNumber("Price", 30)
.withJSON("VendorInfo", vendorDocument);
PutItemOutcome outcome = table.putItem(item);
```
## Abrufen eines Elements
Um ein einzelnes Element abzurufen, verwenden Sie die `getItem`-Methode eines `Table`-Objekts. Dazu gehen Sie wie folgt vor:
1. Erstellen Sie eine Instance der `DynamoDB`-Klasse.
1. Erstellen Sie eine Instance der `Table`-Klasse, um die Tabelle zu repräsentieren, mit der Sie arbeiten möchten.
1. Rufen Sie die `getItem`-Methode für die `Table`-Instance auf. Sie müssen den Primärschlüssel des Elements angeben, das Sie abrufen möchten.
Im folgenden Java-Codebeispiel werden die vorherigen Schritte veranschaulicht. Im Codebeispiel wird das Element abgerufen, das den angegebenen Partitionsschlüssel aufweist.
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB dynamoDB = new DynamoDB(client);
Table table = dynamoDB.getTable("ProductCatalog");
Item item = table.getItem("Id", 210);
```
### Angeben eines optionalen Parameters
Neben den erforderlichen Parametern können Sie auch optionale Parameter für die `getItem`-Methode angeben. Zum Beispiel verwendet das folgende Java-Codebeispiel eine optionale Methode zum Abrufen nur einer bestimmten Liste von Attributen und zum Angeben von Strongly Consistent-Lesevorgängen. (Weitere Informationen zur Lesekonsistenz finden Sie unter [DynamoDB-Lesekonsistenz](HowItWorks.ReadConsistency.md).)
Sie können einen `ProjectionExpression` verwenden, um nur spezifische Attribute oder Elemente anstelle eines ganzen Elements abzurufen. Ein `ProjectionExpression` kann Attribute auf oberster Ebene oder verschachtelte Attribute mithilfe von Dokumentpfaden angeben. Weitere Informationen finden Sie unter [Verwenden von Projektionsausdrücken in DynamoDB](Expressions.ProjectionExpressions.md).
Mit den Parametern der `getItem`-Methode kann keine Read Consistency angegeben werden. Sie können jedoch eine `GetItemSpec` erstellen, die vollständigen Zugriff auf die Eingaben für die `GetItem`-Low-Level-Operation bietet. Durch das Codebeispiel unten wird eine `GetItemSpec` erstellt. Es verwendet diese Spezifikation als Eingabe für die `getItem`-Methode.
**Example**
```
GetItemSpec spec = new GetItemSpec()
.withPrimaryKey("Id", 206)
.withProjectionExpression("Id, Title, RelatedItems[0], Reviews.FiveStar")
.withConsistentRead(true);
Item item = table.getItem(spec);
System.out.println(item.toJSONPretty());
```
Um ein `Item` in einem vom Menschen lesbaren Format zu drucken, verwenden Sie die Methode `toJSONPretty`. Die Ausgabe aus dem vorherigen Beispiel sieht wie folgt aus.
```
{
"RelatedItems" : [ 341 ],
"Reviews" : {
"FiveStar" : [ "Excellent! Can't recommend it highly enough! Buy it!", "Do yourself a favor and buy this" ]
},
"Id" : 123,
"Title" : "20-Bicycle 123"
}
```
### GetItem und JSON-Dokumente
Im Abschnitt [PutItem und JSON-Dokumente](#PutItemJavaDocumentAPI.JSON) haben Sie ein JSON-Dokument in einem `Map`-Attribut mit dem Namen `VendorInfo` gespeichert. Sie können die `getItem`-Methode verwenden, um das gesamte Dokument im JSON-Format abzurufen. Sie können auch die Dokumentpfadnotation verwenden, um nur einige der Elemente des Dokuments abzurufen. Das folgende Java-Codebeispiel veranschaulicht diese Vorgehensweisen.
```
GetItemSpec spec = new GetItemSpec()
.withPrimaryKey("Id", 210);
System.out.println("All vendor info:");
spec.withProjectionExpression("VendorInfo");
System.out.println(table.getItem(spec).toJSON());
System.out.println("A single vendor:");
spec.withProjectionExpression("VendorInfo.V03");
System.out.println(table.getItem(spec).toJSON());
System.out.println("First office location for this vendor:");
spec.withProjectionExpression("VendorInfo.V03.Offices[0]");
System.out.println(table.getItem(spec).toJSON());
```
Die Ausgabe aus dem vorherigen Beispiel sieht wie folgt aus.
```
All vendor info:
{"VendorInfo":{"V03":{"Name":"Better Buy Books","Offices":["Tokyo","Los Angeles","Sydney"]},"V02":{"Name":"New Publishers, Inc.","Offices":["London","New York"]},"V01":{"Name":"Acme Books","Offices":["Seattle"]}}}
A single vendor:
{"VendorInfo":{"V03":{"Name":"Better Buy Books","Offices":["Tokyo","Los Angeles","Sydney"]}}}
First office location for a single vendor:
{"VendorInfo":{"V03":{"Offices":["Tokyo"]}}}
```
**Anmerkung**
Mit der `toJSON`-Methode können Sie jedes beliebige Element (oder seine Attribute) in eine JSON-formatierte Zeichenfolge umwandeln. Das folgende Codeausschnitt ruft mehrere Attribute auf oberster Ebene und verschachtelte Attribute ab und druckt die Ergebnisse im JSON-Format.
```
GetItemSpec spec = new GetItemSpec()
.withPrimaryKey("Id", 210)
.withProjectionExpression("VendorInfo.V01, Title, Price");
Item item = table.getItem(spec);
System.out.println(item.toJSON());
```
Die Ausgabe sieht wie folgt aus.
```
{"VendorInfo":{"V01":{"Name":"Acme Books","Offices":["Seattle"]}},"Price":30,"Title":"Book 210 Title"}
```
## Batch Write: Einfügen und Löschen mehrerer Elemente
*Batch Write* bezieht sich auf das Einfügen und Löschen mehrerer Elemente in einem Batch. Die `batchWriteItem`-Methode ermöglicht Ihnen das Einfügen und Löschen von mehreren Elementen aus einer oder mehreren Tabellen anhand eines einzigen Aufrufs. Im Folgenden finden Sie die Schritte zum Einfügen oder Löschen mehrerer Elemente mithilfe der AWS SDK für Java Dokument-API.
1. Erstellen Sie eine Instance der `DynamoDB`-Klasse.
1. Erstellen Sie eine Instance der `TableWriteItems`-Klasse, die alle Einfügen- und Löschen-Operationen für eine Tabelle beschreibt. Wenn Sie mit einer einzigen BatchWrite-Operation in mehrere Tabellen schreiben möchten, müssen Sie eine `TableWriteItems`-Instance pro Tabelle erstellen.
1. Rufen Sie die `batchWriteItem`-Methode auf, indem Sie das bzw. die `TableWriteItems`-Objekt(e) bereitstellen, das/die Sie im vorangegangenen Schritt erstellt haben.
1. Verarbeiten Sie die Antwort. Überprüfen Sie, ob in der Antwort nicht verarbeitete Anforderungselemente zurückgegeben wurden. Dies kann der Fall sein, wenn Sie das Kontingent für den bereitgestellten Durchsatz erreichen oder ein anderer vorübergehender Fehler auftritt. Außerdem begrenzt DynamoDB die Anforderungsgröße und die Anzahl der Vorgänge, die Sie in einer Anforderung angeben können. Wenn Sie diese Limits überschreiten, wird die Anforderung von DynamoDB abgelehnt. Weitere Informationen finden Sie unter [Kontingente in Amazon DynamoDB](ServiceQuotas.md).
Im folgenden Java-Codebeispiel werden die vorherigen Schritte veranschaulicht. Das folgende Beispiel führt eine `batchWriteItem`-Operation für zwei Tabellen durch: `Forum` und `Thread`. Die entsprechenden `TableWriteItems`-Objekte definieren die folgenden Aktionen:
+ Einfügen eines Elements in die `Forum`-Tabelle
+ Einfügen und Löschen eines Elements in der `Thread`-Tabelle
Der Code ruft dann `batchWriteItem` auf, um die Operation durchzuführen.
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB dynamoDB = new DynamoDB(client);
TableWriteItems forumTableWriteItems = new TableWriteItems("Forum")
.withItemsToPut(
new Item()
.withPrimaryKey("Name", "Amazon RDS")
.withNumber("Threads", 0));
TableWriteItems threadTableWriteItems = new TableWriteItems("Thread")
.withItemsToPut(
new Item()
.withPrimaryKey("ForumName","Amazon RDS","Subject","Amazon RDS Thread 1")
.withHashAndRangeKeysToDelete("ForumName","Some partition key value", "Amazon S3", "Some sort key value");
BatchWriteItemOutcome outcome = dynamoDB.batchWriteItem(forumTableWriteItems, threadTableWriteItems);
// Code for checking unprocessed items is omitted in this example
```
Ein funktionierendes Beispiel finden Sie unter [Beispiel: Batch-Schreibvorgang mit der AWS SDK für Java Dokument-API](batch-operation-document-api-java.md#JavaDocumentAPIBatchWrite).
## Batch Get: Abrufen mehrerer Elemente
Die `batchGetItem`-Methode ermöglicht Ihnen das Abrufen mehrerer Elemente aus einer oder mehreren Tabellen. Um ein einzelnes Element abzurufen, können Sie die `getItem`-Methode verwenden.
Dazu gehen Sie wie folgt vor:
1. Erstellen Sie eine Instance der `DynamoDB`-Klasse.
1. Erstellen Sie eine Instance der `TableKeysAndAttributes`-Klasse, die eine Liste der Primärschlüsselwerte beschreibt, die von einer Tabelle abgerufen werden sollen. Wenn Sie mit einer einzigen BatchGet-Operation aus mehreren Tabellen lesen möchten, müssen Sie eine `TableKeysAndAttributes`-Instance pro Tabelle erstellen.
1. Rufen Sie die `batchGetItem`-Methode auf, indem Sie das bzw. die `TableKeysAndAttributes`-Objekt(e) bereitstellen, das/die Sie im vorangegangenen Schritt erstellt haben.
Im folgenden Java-Codebeispiel werden die vorherigen Schritte veranschaulicht. In dem Beispiel werden zwei Elemente aus der `Forum`-Tabelle und drei Elemente aus der `Thread`-Tabelle abgerufen.
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB dynamoDB = new DynamoDB(client);
TableKeysAndAttributes forumTableKeysAndAttributes = new TableKeysAndAttributes(forumTableName);
forumTableKeysAndAttributes.addHashOnlyPrimaryKeys("Name",
"Amazon S3",
"Amazon DynamoDB");
TableKeysAndAttributes threadTableKeysAndAttributes = new TableKeysAndAttributes(threadTableName);
threadTableKeysAndAttributes.addHashAndRangePrimaryKeys("ForumName", "Subject",
"Amazon DynamoDB","DynamoDB Thread 1",
"Amazon DynamoDB","DynamoDB Thread 2",
"Amazon S3","S3 Thread 1");
BatchGetItemOutcome outcome = dynamoDB.batchGetItem(
forumTableKeysAndAttributes, threadTableKeysAndAttributes);
for (String tableName : outcome.getTableItems().keySet()) {
System.out.println("Items in table " + tableName);
List- items = outcome.getTableItems().get(tableName);
for (Item item : items) {
System.out.println(item);
}
}
```
### Angeben eines optionalen Parameters
Neben den erforderlichen Parametern können Sie bei Verwendung von `batchGetItem` auch optionale Parameter angeben. Beispielsweise können Sie einen `ProjectionExpression` mit jedem `TableKeysAndAttributes`, das Sie definieren, bereitstellen. So können Sie die Attribute angeben, die aus der Tabelle abgerufen werden sollen.
Im folgenden C\$1-Codebeispiel werden zwei Elemente aus der `Forum`-Tabelle abgerufen. Der Parameter `withProjectionExpression` gibt an, dass nur das Attribut `Threads` abgerufen werden soll.
**Example**
```
TableKeysAndAttributes forumTableKeysAndAttributes = new TableKeysAndAttributes("Forum")
.withProjectionExpression("Threads");
forumTableKeysAndAttributes.addHashOnlyPrimaryKeys("Name",
"Amazon S3",
"Amazon DynamoDB");
BatchGetItemOutcome outcome = dynamoDB.batchGetItem(forumTableKeysAndAttributes);
```
## Aktualisieren eines Elements
Die `updateItem`-Methode eines `Table`-Objekts kann vorhandene Attributwerte aktualisieren, neue Attribute hinzuzufügen oder Attribute aus einem vorhandenen Element löschen.
Die `updateItem`-Methode verhält sich wie folgt:
+ Wenn kein Element vorhanden ist (kein Element in der Tabelle mit dem angegebenen Primärschlüssel), fügt `updateItem` der Tabelle ein neues Element hinzu.
+ Wenn ein Element vorhanden ist, führt `updateItem` die Aktualisierung wie vom `UpdateExpression`-Parameter angegeben aus.
**Anmerkung**
Es ist auch möglich, ein Element mit `putItem` zu "aktualisieren". Wenn Sie z. B. `putItem` aufrufen, um der Tabelle ein Element hinzuzufügen, aber bereits ein Element mit dem angegebenen Primärschlüssel vorhanden ist, wird das gesamte Element von `putItem` ersetzt. Wenn Attribute in dem vorhandenen Element nicht in der Eingabe angegeben sind, werden diese Attribute von `putItem` aus dem Element entfernt.
Im Allgemeinen empfehlen wir, `updateItem` immer dann zu verwenden, wenn Sie Elementattribute ändern möchten. Die `updateItem`-Methode ändert nur die Elementattribute, die Sie in der Eingabe angeben. Die anderen Attribute im Element bleiben unverändert.
Dazu gehen Sie wie folgt vor:
1. Erstellen Sie eine Instance der `Table`-Klasse, um die Tabelle zu repräsentieren, mit der Sie arbeiten möchten.
1. Rufen Sie die `updateTable`-Methode für die `Table`-Instance auf. Sie müssen den Primärschlüssel des abzurufenden Elements und einen `UpdateExpression` angeben, der die zu ändernden Attribute beschreibt und mitteilt, wie diese geändert werden sollen.
Im folgenden Java-Codebeispiel werden die vorherigen Aufgaben veranschaulicht. Das Beispiel aktualisiert ein Buchelement in der `ProductCatalog`-Tabelle. Es wird ein neuer Autor zum Satz der `Authors` hinzugefügt und das vorhandene `ISBN`-Attribut wird gelöscht. Darüber hinaus wird auch der Preis um eins gesenkt.
Im `ExpressionAttributeValues` wird eine `UpdateExpression`-Zuordnung verwendet. Die Platzhalter `:val1` und `:val2` werden zur Laufzeit durch die tatsächlichen Werte für `Authors` und `Price` ersetzt.
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB dynamoDB = new DynamoDB(client);
Table table = dynamoDB.getTable("ProductCatalog");
Map expressionAttributeNames = new HashMap();
expressionAttributeNames.put("#A", "Authors");
expressionAttributeNames.put("#P", "Price");
expressionAttributeNames.put("#I", "ISBN");
Map expressionAttributeValues = new HashMap();
expressionAttributeValues.put(":val1",
new HashSet(Arrays.asList("Author YY","Author ZZ")));
expressionAttributeValues.put(":val2", 1); //Price
UpdateItemOutcome outcome = table.updateItem(
"Id", // key attribute name
101, // key attribute value
"add #A :val1 set #P = #P - :val2 remove #I", // UpdateExpression
expressionAttributeNames,
expressionAttributeValues);
```
### Angeben eines optionalen Parameters
Neben den erforderlichen Parametern können Sie auch optionale Parameter für die `updateItem`-Methode angeben, z. B. eine Bedingung, die erfüllt werden muss, damit die Aktualisierung erfolgt. Wenn die von Ihnen angegebene Bedingung nicht erfüllt ist, wird AWS SDK für Java eine `ConditionalCheckFailedException` ausgelöst. Beim folgenden Java-Codebeispiel wird der Preis eines Buchelements bedingungsabhängig auf 25 erhöht. Das Beispiel zeigt einen `ConditionExpression`, der besagt, dass der Preis nur aktualisiert werden soll, wenn der vorhandene Preis 20 lautet.
**Example**
```
Table table = dynamoDB.getTable("ProductCatalog");
Map expressionAttributeNames = new HashMap();
expressionAttributeNames.put("#P", "Price");
Map expressionAttributeValues = new HashMap();
expressionAttributeValues.put(":val1", 25); // update Price to 25...
expressionAttributeValues.put(":val2", 20); //...but only if existing Price is 20
UpdateItemOutcome outcome = table.updateItem(
new PrimaryKey("Id",101),
"set #P = :val1", // UpdateExpression
"#P = :val2", // ConditionExpression
expressionAttributeNames,
expressionAttributeValues);
```
### Unteilbarer Zähler
Sie können `updateItem` verwenden, um einen unteilbaren Zähler zu implementieren, mit dem der Wert eines bestehenden Attributs erhöht oder verringert wird, ohne andere Schreibanforderungen zu beeinflussen. Zum Erhöhen eines unteilbaren Zählers verwenden Sie einen `UpdateExpression` mit einer `set`-Aktion, um einem vorhandenen Attribut vom Typ `Number` einen numerischen Wert hinzuzufügen.
Das folgende Codebeispiel zeigt diesen Vorgang und erhöht das Attribut `Quantity` um eins. Es zeigt auch die Verwendung des Parameters `ExpressionAttributeNames` in einem `UpdateExpression`.
```
Table table = dynamoDB.getTable("ProductCatalog");
Map expressionAttributeNames = new HashMap();
expressionAttributeNames.put("#p", "PageCount");
Map expressionAttributeValues = new HashMap();
expressionAttributeValues.put(":val", 1);
UpdateItemOutcome outcome = table.updateItem(
"Id", 121,
"set #p = #p + :val",
expressionAttributeNames,
expressionAttributeValues);
```
## Löschen eines Elements
Die `deleteItem`-Methode löscht ein Element aus einer Tabelle. Sie müssen den Primärschlüssel des Elements bereitstellen, das Sie löschen möchten.
Dazu gehen Sie wie folgt vor:
1. Erstellen Sie eine Instance des `DynamoDB`-Clients.
1. Rufen Sie die `deleteItem`-Methode durch Angabe des Schlüssels des Elements auf, das Sie löschen möchten.
Das folgende Java-Codebeispiel veranschaulicht diese Vorgehensweisen.
**Example**
```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
DynamoDB dynamoDB = new DynamoDB(client);
Table table = dynamoDB.getTable("ProductCatalog");
DeleteItemOutcome outcome = table.deleteItem("Id", 101);
```
### Angeben eines optionalen Parameters
Sie können für `deleteItem` optionale Parameter angeben. Das folgende Java-Codebeispiel enthält einen `ConditionExpression`, der besagt, dass ein Buchelement im `InPublication` nur dann gelöscht werden darf, wenn das Buch nicht mehr veröffentlicht wird (das Attribut `ProductCatalog` ist False).
**Example**
```
Map expressionAttributeValues = new HashMap();
expressionAttributeValues.put(":val", false);
DeleteItemOutcome outcome = table.deleteItem("Id",103,
"InPublication = :val",
null, // ExpressionAttributeNames - not used in this example
expressionAttributeValues);
```
# Beispiel: CRUD-Operationen mit der AWS SDK für Java Dokument-API
Das folgende Codebeispiel veranschaulicht CRUD-Operationen für ein Amazon-DynamoDB-Element. In dem Beispiel wird ein Element erstellt, abgerufen, es werden verschiedene Aktualisierungen durchgeführt und es wird schließlich gelöscht.
**Anmerkung**
Das SDK für Java stellt auch ein Objektpersistenzmodell bereit, mit dem Sie Ihre clientseitigen Klassen DynamoDB-Tabellen zuordnen können. Mit diesem Ansatz können Sie die Codemenge, die Sie schreiben müssen, verringern. Weitere Informationen finden Sie unter [Java 1.x: Dynamo DBMapper](DynamoDBMapper.md).
**Anmerkung**
In diesem Codebeispiel wird davon ausgegangen, dass Sie bereits Daten für Ihr Konto in DynamoDB geladen haben, indem Sie die Anweisungen im [Erstellen von Tabellen und Laden von Daten für Codebeispiele in DynamoDB](SampleData.md)-Abschnitt befolgen.
step-by-stepAnweisungen zur Ausführung des folgenden Beispiels finden Sie unter[Java-Codebeispiele](CodeSamples.Java.md).
```
package com.amazonaws.codesamples.document;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DeleteItemOutcome;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.UpdateItemOutcome;
import com.amazonaws.services.dynamodbv2.document.spec.DeleteItemSpec;
import com.amazonaws.services.dynamodbv2.document.spec.UpdateItemSpec;
import com.amazonaws.services.dynamodbv2.document.utils.NameMap;
import com.amazonaws.services.dynamodbv2.document.utils.ValueMap;
import com.amazonaws.services.dynamodbv2.model.ReturnValue;
public class DocumentAPIItemCRUDExample {
static AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
static DynamoDB dynamoDB = new DynamoDB(client);
static String tableName = "ProductCatalog";
public static void main(String[] args) throws IOException {
createItems();
retrieveItem();
// Perform various updates.
updateMultipleAttributes();
updateAddNewAttribute();
updateExistingAttributeConditionally();
// Delete the item.
deleteItem();
}
private static void createItems() {
Table table = dynamoDB.getTable(tableName);
try {
Item item = new Item().withPrimaryKey("Id", 120).withString("Title", "Book 120 Title")
.withString("ISBN", "120-1111111111")
.withStringSet("Authors", new HashSet(Arrays.asList("Author12", "Author22")))
.withNumber("Price", 20).withString("Dimensions", "8.5x11.0x.75").withNumber("PageCount", 500)
.withBoolean("InPublication", false).withString("ProductCategory", "Book");
table.putItem(item);
item = new Item().withPrimaryKey("Id", 121).withString("Title", "Book 121 Title")
.withString("ISBN", "121-1111111111")
.withStringSet("Authors", new HashSet(Arrays.asList("Author21", "Author 22")))
.withNumber("Price", 20).withString("Dimensions", "8.5x11.0x.75").withNumber("PageCount", 500)
.withBoolean("InPublication", true).withString("ProductCategory", "Book");
table.putItem(item);
} catch (Exception e) {
System.err.println("Create items failed.");
System.err.println(e.getMessage());
}
}
private static void retrieveItem() {
Table table = dynamoDB.getTable(tableName);
try {
Item item = table.getItem("Id", 120, "Id, ISBN, Title, Authors", null);
System.out.println("Printing item after retrieving it....");
System.out.println(item.toJSONPretty());
} catch (Exception e) {
System.err.println("GetItem failed.");
System.err.println(e.getMessage());
}
}
private static void updateAddNewAttribute() {
Table table = dynamoDB.getTable(tableName);
try {
UpdateItemSpec updateItemSpec = new UpdateItemSpec().withPrimaryKey("Id", 121)
.withUpdateExpression("set #na = :val1").withNameMap(new NameMap().with("#na", "NewAttribute"))
.withValueMap(new ValueMap().withString(":val1", "Some value"))
.withReturnValues(ReturnValue.ALL_NEW);
UpdateItemOutcome outcome = table.updateItem(updateItemSpec);
// Check the response.
System.out.println("Printing item after adding new attribute...");
System.out.println(outcome.getItem().toJSONPretty());
} catch (Exception e) {
System.err.println("Failed to add new attribute in " + tableName);
System.err.println(e.getMessage());
}
}
private static void updateMultipleAttributes() {
Table table = dynamoDB.getTable(tableName);
try {
UpdateItemSpec updateItemSpec = new UpdateItemSpec().withPrimaryKey("Id", 120)
.withUpdateExpression("add #a :val1 set #na=:val2")
.withNameMap(new NameMap().with("#a", "Authors").with("#na", "NewAttribute"))
.withValueMap(
new ValueMap().withStringSet(":val1", "Author YY", "Author ZZ").withString(":val2",
"someValue"))
.withReturnValues(ReturnValue.ALL_NEW);
UpdateItemOutcome outcome = table.updateItem(updateItemSpec);
// Check the response.
System.out.println("Printing item after multiple attribute update...");
System.out.println(outcome.getItem().toJSONPretty());
} catch (Exception e) {
System.err.println("Failed to update multiple attributes in " + tableName);
System.err.println(e.getMessage());
}
}
private static void updateExistingAttributeConditionally() {
Table table = dynamoDB.getTable(tableName);
try {
// Specify the desired price (25.00) and also the condition (price =
// 20.00)
UpdateItemSpec updateItemSpec = new UpdateItemSpec().withPrimaryKey("Id", 120)
.withReturnValues(ReturnValue.ALL_NEW).withUpdateExpression("set #p = :val1")
.withConditionExpression("#p = :val2").withNameMap(new NameMap().with("#p", "Price"))
.withValueMap(new ValueMap().withNumber(":val1", 25).withNumber(":val2", 20));
UpdateItemOutcome outcome = table.updateItem(updateItemSpec);
// Check the response.
System.out.println("Printing item after conditional update to new attribute...");
System.out.println(outcome.getItem().toJSONPretty());
} catch (Exception e) {
System.err.println("Error updating item in " + tableName);
System.err.println(e.getMessage());
}
}
private static void deleteItem() {
Table table = dynamoDB.getTable(tableName);
try {
DeleteItemSpec deleteItemSpec = new DeleteItemSpec().withPrimaryKey("Id", 120)
.withConditionExpression("#ip = :val").withNameMap(new NameMap().with("#ip", "InPublication"))
.withValueMap(new ValueMap().withBoolean(":val", false)).withReturnValues(ReturnValue.ALL_OLD);
DeleteItemOutcome outcome = table.deleteItem(deleteItemSpec);
// Check the response.
System.out.println("Printing item that was deleted...");
System.out.println(outcome.getItem().toJSONPretty());
} catch (Exception e) {
System.err.println("Error deleting item in " + tableName);
System.err.println(e.getMessage());
}
}
}
```
# Beispiel: Batch-Operationen mithilfe der AWS SDK für Java Dokument-API
Dieser Abschnitt enthält Beispiele für Batch-Write- und Batch-Abruf-Operationen in Amazon DynamoDB mithilfe der AWS SDK für Java Document API.
**Anmerkung**
Das SDK für Java stellt auch ein Objektpersistenzmodell bereit, mit dem Sie Ihre clientseitigen Klassen DynamoDB-Tabellen zuordnen können. Mit diesem Ansatz können Sie die Codemenge, die Sie schreiben müssen, verringern. Weitere Informationen finden Sie unter [Java 1.x: Dynamo DBMapper](DynamoDBMapper.md).
**Topics**
+ [Beispiel: Batch-Schreibvorgang mit der AWS SDK für Java Dokument-API](#JavaDocumentAPIBatchWrite)
+ [Beispiel: Batch-Abruf-Vorgang mit der AWS SDK für Java Dokument-API](#JavaDocumentAPIBatchGet)
## Beispiel: Batch-Schreibvorgang mit der AWS SDK für Java Dokument-API
Das folgende Java-Beispielcode verwendet die `batchWriteItem`-Methode zur Durchführung der folgenden Operationen zum Einfügen und Löschen:
+ Einfügen eines Elements in die `Forum`-Tabelle
+ Einfügen und Löschen eines Elements aus der `Thread`-Tabelle
Bei der Erstellung Ihrer BatchWrite-Anforderung können Sie eine beliebige Anzahl von Einfüge- und Lösch-Anforderungen angeben. `batchWriteItem` begrenzt jedoch die Größe einer BatchWrite-Anforderung sowie die Anzahl der Einfüge- und Löschoperationen in einer einzelnen BatchWrite-Operation. Wenn Ihre Anforderung diese Grenzwerte überschreitet, wird sie abgelehnt. Wenn die Tabelle nicht über ausreichend bereitgestellten Durchsatz für diese Anforderung verfügt, werden nicht verarbeitete Anforderungselemente in der Antwort zurückgegeben.
Im folgenden Beispiel wird die Antwort auf unverarbeitete Anforderungselemente überprüft. Liegen unverarbeitete Elemente vor, wird der Vorgang wiederholt und die `batchWriteItem`-Anforderung mit unverarbeiteten Elementen wird erneut gesendet. Wenn Sie die Beispiele in dieser Anleitung befolgt haben, sollten Sie die Tabellen `Forum` und `Thread` bereits erstellt haben. Sie können diese Tabellen auch programmgesteuert erstellen und auf die gleiche Weise Beispieldaten hochladen. Weitere Informationen finden Sie unter [Erstellen von Beispieltabellen und Hochladen von Daten mit dem AWS SDK für Java](AppendixSampleDataCodeJava.md).
step-by-stepAnweisungen zum Testen des folgenden Beispiels finden Sie unter[Java-Codebeispiele](CodeSamples.Java.md).
**Example**
```
package com.amazonaws.codesamples.document;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.BatchWriteItemOutcome;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.TableWriteItems;
import com.amazonaws.services.dynamodbv2.model.WriteRequest;
public class DocumentAPIBatchWrite {
static AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
static DynamoDB dynamoDB = new DynamoDB(client);
static String forumTableName = "Forum";
static String threadTableName = "Thread";
public static void main(String[] args) throws IOException {
writeMultipleItemsBatchWrite();
}
private static void writeMultipleItemsBatchWrite() {
try {
// Add a new item to Forum
TableWriteItems forumTableWriteItems = new TableWriteItems(forumTableName) // Forum
.withItemsToPut(new Item().withPrimaryKey("Name", "Amazon RDS").withNumber("Threads", 0));
// Add a new item, and delete an existing item, from Thread
// This table has a partition key and range key, so need to specify
// both of them
TableWriteItems threadTableWriteItems = new TableWriteItems(threadTableName)
.withItemsToPut(
new Item().withPrimaryKey("ForumName", "Amazon RDS", "Subject", "Amazon RDS Thread 1")
.withString("Message", "ElastiCache Thread 1 message")
.withStringSet("Tags", new HashSet(Arrays.asList("cache", "in-memory"))))
.withHashAndRangeKeysToDelete("ForumName", "Subject", "Amazon S3", "S3 Thread 100");
System.out.println("Making the request.");
BatchWriteItemOutcome outcome = dynamoDB.batchWriteItem(forumTableWriteItems, threadTableWriteItems);
do {
// Check for unprocessed keys which could happen if you exceed
// provisioned throughput
Map> unprocessedItems = outcome.getUnprocessedItems();
if (outcome.getUnprocessedItems().size() == 0) {
System.out.println("No unprocessed items found");
} else {
System.out.println("Retrieving the unprocessed items");
outcome = dynamoDB.batchWriteItemUnprocessed(unprocessedItems);
}
} while (outcome.getUnprocessedItems().size() > 0);
} catch (Exception e) {
System.err.println("Failed to retrieve items: ");
e.printStackTrace(System.err);
}
}
}
```
## Beispiel: Batch-Abruf-Vorgang mit der AWS SDK für Java Dokument-API
Das folgende Java-Codebeispiel verwendet die `batchGetItem`-Methode zum Abrufen mehrerer Elemente aus den Tabellen `Forum` und `Thread`. Die `BatchGetItemRequest` gibt die Tabellennamen sowie eine Liste der Schlüssel für jedes abzurufende Element an. In dem Beispiel wird die Antwort durch Drucken der abgerufenen Elemente verarbeitet.
**Anmerkung**
In diesem Codebeispiel wird davon ausgegangen, dass Sie bereits Daten für Ihr Konto in DynamoDB geladen haben, indem Sie die Anweisungen im [Erstellen von Tabellen und Laden von Daten für Codebeispiele in DynamoDB](SampleData.md)-Abschnitt befolgen.
step-by-stepAnweisungen zur Ausführung des folgenden Beispiels finden Sie unter[Java-Codebeispiele](CodeSamples.Java.md).
**Example**
```
package com.amazonaws.codesamples.document;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.BatchGetItemOutcome;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.TableKeysAndAttributes;
import com.amazonaws.services.dynamodbv2.model.KeysAndAttributes;
public class DocumentAPIBatchGet {
static AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
static DynamoDB dynamoDB = new DynamoDB(client);
static String forumTableName = "Forum";
static String threadTableName = "Thread";
public static void main(String[] args) throws IOException {
retrieveMultipleItemsBatchGet();
}
private static void retrieveMultipleItemsBatchGet() {
try {
TableKeysAndAttributes forumTableKeysAndAttributes = new TableKeysAndAttributes(forumTableName);
// Add a partition key
forumTableKeysAndAttributes.addHashOnlyPrimaryKeys("Name", "Amazon S3", "Amazon DynamoDB");
TableKeysAndAttributes threadTableKeysAndAttributes = new TableKeysAndAttributes(threadTableName);
// Add a partition key and a sort key
threadTableKeysAndAttributes.addHashAndRangePrimaryKeys("ForumName", "Subject", "Amazon DynamoDB",
"DynamoDB Thread 1", "Amazon DynamoDB", "DynamoDB Thread 2", "Amazon S3", "S3 Thread 1");
System.out.println("Making the request.");
BatchGetItemOutcome outcome = dynamoDB.batchGetItem(forumTableKeysAndAttributes,
threadTableKeysAndAttributes);
Map unprocessed = null;
do {
for (String tableName : outcome.getTableItems().keySet()) {
System.out.println("Items in table " + tableName);
List
- items = outcome.getTableItems().get(tableName);
for (Item item : items) {
System.out.println(item.toJSONPretty());
}
}
// Check for unprocessed keys which could happen if you exceed
// provisioned
// throughput or reach the limit on response size.
unprocessed = outcome.getUnprocessedKeys();
if (unprocessed.isEmpty()) {
System.out.println("No unprocessed keys found");
} else {
System.out.println("Retrieving the unprocessed keys");
outcome = dynamoDB.batchGetItemUnprocessed(unprocessed);
}
} while (!unprocessed.isEmpty());
} catch (Exception e) {
System.err.println("Failed to retrieve items.");
System.err.println(e.getMessage());
}
}
}
```
# Beispiel: Umgang mit binären Typattributen mithilfe der AWS SDK für Java Dokument-API
Das folgende Java-Codebeispiel veranschaulicht die Verarbeitung von Attributen des Typs Binärzahl. Bei dem Beispiel wird der `Reply`-Tabelle ein Element hinzugefügt. Das Element enthält ein Binärtypattribut (`ExtendedMessage`), in dem komprimierte Daten gespeichert sind. Daraufhin wird das Element abgerufen und es werden alle Attributwerte gedruckt. Zur Veranschaulichung wird in dem Beispiel die `GZIPOutputStream`-Klasse verwendet, um einen Beispiel-Stream zu komprimieren und dem `ExtendedMessage`-Attribut zuzuweisen. Wenn das Binärattribut abgerufen wird, wird es mit der `GZIPInputStream`-Klasse dekomprimiert.
**Anmerkung**
Das SDK für Java stellt auch ein Objektpersistenzmodell bereit, mit dem Sie Ihre clientseitigen Klassen DynamoDB-Tabellen zuordnen können. Mit diesem Ansatz können Sie die Codemenge, die Sie schreiben müssen, verringern. Weitere Informationen finden Sie unter [Java 1.x: Dynamo DBMapper](DynamoDBMapper.md).
Wenn Sie die Schritte im Abschnitt [Erstellen von Tabellen und Laden von Daten für Codebeispiele in DynamoDB](SampleData.md) befolgt haben, sollten Sie die `Reply`-Tabelle bereits erstellt haben. Sie können diese Tabelle auch programmgesteuert erstellen. Weitere Informationen finden Sie unter [Erstellen von Beispieltabellen und Hochladen von Daten mit dem AWS SDK für Java](AppendixSampleDataCodeJava.md).
step-by-stepAnweisungen zum Testen des folgenden Beispiels finden Sie unter[Java-Codebeispiele](CodeSamples.Java.md).
**Example**
```
package com.amazonaws.codesamples.document;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TimeZone;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.spec.GetItemSpec;
public class DocumentAPIItemBinaryExample {
static AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
static DynamoDB dynamoDB = new DynamoDB(client);
static String tableName = "Reply";
static SimpleDateFormat dateFormatter = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
public static void main(String[] args) throws IOException {
try {
// Format the primary key values
String threadId = "Amazon DynamoDB#DynamoDB Thread 2";
dateFormatter.setTimeZone(TimeZone.getTimeZone("UTC"));
String replyDateTime = dateFormatter.format(new Date());
// Add a new reply with a binary attribute type
createItem(threadId, replyDateTime);
// Retrieve the reply with a binary attribute type
retrieveItem(threadId, replyDateTime);
// clean up by deleting the item
deleteItem(threadId, replyDateTime);
} catch (Exception e) {
System.err.println("Error running the binary attribute type example: " + e);
e.printStackTrace(System.err);
}
}
public static void createItem(String threadId, String replyDateTime) throws IOException {
Table table = dynamoDB.getTable(tableName);
// Craft a long message
String messageInput = "Long message to be compressed in a lengthy forum reply";
// Compress the long message
ByteBuffer compressedMessage = compressString(messageInput.toString());
table.putItem(new Item().withPrimaryKey("Id", threadId).withString("ReplyDateTime", replyDateTime)
.withString("Message", "Long message follows").withBinary("ExtendedMessage", compressedMessage)
.withString("PostedBy", "User A"));
}
public static void retrieveItem(String threadId, String replyDateTime) throws IOException {
Table table = dynamoDB.getTable(tableName);
GetItemSpec spec = new GetItemSpec().withPrimaryKey("Id", threadId, "ReplyDateTime", replyDateTime)
.withConsistentRead(true);
Item item = table.getItem(spec);
// Uncompress the reply message and print
String uncompressed = uncompressString(ByteBuffer.wrap(item.getBinary("ExtendedMessage")));
System.out.println("Reply message:\n" + " Id: " + item.getString("Id") + "\n" + " ReplyDateTime: "
+ item.getString("ReplyDateTime") + "\n" + " PostedBy: " + item.getString("PostedBy") + "\n"
+ " Message: "
+ item.getString("Message") + "\n" + " ExtendedMessage (uncompressed): " + uncompressed + "\n");
}
public static void deleteItem(String threadId, String replyDateTime) {
Table table = dynamoDB.getTable(tableName);
table.deleteItem("Id", threadId, "ReplyDateTime", replyDateTime);
}
private static ByteBuffer compressString(String input) throws IOException {
// Compress the UTF-8 encoded String into a byte[]
ByteArrayOutputStream baos = new ByteArrayOutputStream();
GZIPOutputStream os = new GZIPOutputStream(baos);
os.write(input.getBytes("UTF-8"));
os.close();
baos.close();
byte[] compressedBytes = baos.toByteArray();
// The following code writes the compressed bytes to a ByteBuffer.
// A simpler way to do this is by simply calling
// ByteBuffer.wrap(compressedBytes);
// However, the longer form below shows the importance of resetting the
// position of the buffer
// back to the beginning of the buffer if you are writing bytes directly
// to it, since the SDK
// will consider only the bytes after the current position when sending
// data to DynamoDB.
// Using the "wrap" method automatically resets the position to zero.
ByteBuffer buffer = ByteBuffer.allocate(compressedBytes.length);
buffer.put(compressedBytes, 0, compressedBytes.length);
buffer.position(0); // Important: reset the position of the ByteBuffer
// to the beginning
return buffer;
}
private static String uncompressString(ByteBuffer input) throws IOException {
byte[] bytes = input.array();
ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
GZIPInputStream is = new GZIPInputStream(bais);
int chunkSize = 1024;
byte[] buffer = new byte[chunkSize];
int length = 0;
while ((length = is.read(buffer, 0, chunkSize)) != -1) {
baos.write(buffer, 0, length);
}
String result = new String(baos.toByteArray(), "UTF-8");
is.close();
baos.close();
bais.close();
return result;
}
}
```