Programmierschnittstellen, die mit DynamoDB funktionieren - Amazon-DynamoDB
Low-Level-Schnittstellen, die mit DynamoDB funktionierenDokumentschnittstellen, die mit DynamoDB funktionierenSchnittstellen für Objektpersistenz, die mit DynamoDB funktionieren

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.

Programmierschnittstellen, die mit DynamoDB funktionieren

Jedes AWS SDKbietet eine oder mehrere programmatische Schnittstellen für die Arbeit mit Amazon DynamoDB. Diese Schnittstellen reichen von einfachen Low-Level-DynamoDB-Wrapper zu objektorientierten Persistenzschichten. Die verfügbaren Schnittstellen variieren je nach AWS SDK verwendeter Programmiersprache.

Programmatische Schnittstellen sind in verschiedenen Ausführungen AWS SDKs für die Arbeit mit DynamoDB verfügbar.

Der folgende Abschnitt hebt einige der verfügbaren Schnittstellen hervor und verwendet AWS SDK for Java als Beispiel. (Nicht alle Schnittstellen sind in allen verfügbar.) AWS SDKs

Low-Level-Schnittstellen, die mit DynamoDB funktionieren

Jede sprachspezifische Sprache AWS SDK bietet eine Low-Level-Schnittstelle für Amazon DynamoDB mit Methoden, die DynamoDB-Anfragen auf niedriger Ebene sehr ähnlich sind. API

In einigen Fällen müssen Sie die Datentypen der Attribute mithilfe von Datentypbeschreibungen identifizieren, so wie S für Zeichenfolge und N für Zahl.

Anmerkung

Eine Low-Level-Schnittstelle ist in allen sprachspezifischen Sprachen verfügbar. AWS SDK

Das folgende Java-Programm verwendet die Low-Level-Schnittstelle des AWS SDK for Java. 

import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
import software.amazon.awssdk.services.dynamodb.model.GetItemRequest;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * 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 get an item from an Amazon DynamoDB table using the AWS SDK for Java V2,
 * its better practice to use the
 * Enhanced Client, see the EnhancedGetItem example.
 */
public class GetItem {
    public static void main(String[] args) {
        final String usage = """

                Usage:
                    <tableName> <key> <keyVal>

                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<String, AttributeValue> 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<String, AttributeValue> returnedItem = ddb.getItem(request).item();
            if (returnedItem.isEmpty())
                System.out.format("No item found with the key %s!\n", key);
            else {
                Set<String> 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

Viele AWS SDKs bieten eine Dokumentschnittstelle, über die Sie Operationen auf Datenebene (Erstellen, Lesen, Aktualisieren, Löschen) für Tabellen und Indizes ausführen können. Mit einer Dokumentschnittstelle müssen Sie Datentypbeschreibungen nicht angeben. Die Datentypen werden durch die Semantiken der Daten selber bereitgestellt. Diese bieten AWS SDKs auch Methoden zur einfachen Konvertierung von JSON Dokumenten in und aus nativen Amazon DynamoDB DynamoDB-Datentypen.

Anmerkung

Dokumentschnittstellen sind in der Version AWS SDKs für Java verfügbar,. NET, Node.js und JavaScriptSDK.

Das folgende Java-Programm verwendet die Dokumentschnittstelle des AWS SDK for Java. Das Programm erstellt ein Table-Objekt, das die Music-Tabelle repräsentiert und fordert dieses Objekt auf, GetItem zu verwenden, um einen Song abzurufen. Das Programm gibt dann das Jahr aus, in dem der Song veröffentlicht wurde.

Die com.amazonaws.services.dynamodbv2.document.DynamoDB-Klasse implementiert die DynamoDB-Dokumentschnittstelle. Beachten Sie, wie DynamoDB als Wrapper um den Low-Level-Client agiert (AmazonDynamoDB).

package com.amazonaws.codesamples.gsg;

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.GetItemOutcome;
import com.amazonaws.services.dynamodbv2.document.Table;

public class MusicDocumentDemo {

    public static void main(String[] args) {

        AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();
        DynamoDB docClient = new DynamoDB(client);

        Table table = docClient.getTable("Music");
        GetItemOutcome outcome = table.getItemOutcome(
                "Artist", "No One You Know",
                "SongTitle", "Call Me Today");

        int year = outcome.getItem().getInt("Year");
        System.out.println("The song was released in " + year);

    }
}

Schnittstellen für Objektpersistenz, die mit DynamoDB funktionieren

Einige AWS SDKs bieten eine Schnittstelle zur Objektpersistenz, über die Sie keine direkten Datenebenenoperationen ausführen können. Stattdessen erstellen Sie Objekte, die Elemente in Amazon-DynamoDB-Tabellen und Indexe repräsentieren, und interagieren ausschließlich mit diesen Objekten. Auf diese Weise können Sie objektorientierte Codes statt datenbankorientierter Codes schreiben.

Anmerkung

Schnittstellen für Objektpersistenz sind in den Versionen AWS SDKs für Java und verfügbar. NET. Weitere Informationen finden Sie unter Higher-Level-Programmierschnittstellen für DynamoDB für DynamoDB.

import com.example.dynamodb.Customer;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedClient;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbTable;
import software.amazon.awssdk.enhanced.dynamodb.Key;
import software.amazon.awssdk.enhanced.dynamodb.TableSchema;
import software.amazon.awssdk.enhanced.dynamodb.model.GetItemEnhancedRequest;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;

import com.example.dynamodb.Customer;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedClient;
import software.amazon.awssdk.enhanced.dynamodb.DynamoDbTable;
import software.amazon.awssdk.enhanced.dynamodb.Key;
import software.amazon.awssdk.enhanced.dynamodb.TableSchema;
import software.amazon.awssdk.enhanced.dynamodb.model.GetItemEnhancedRequest;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;

/*
 * Before running this code example, create an Amazon DynamoDB table named Customer with these columns:
 *   - id - the id of the record that is the key. Be sure one of the id values is `id101`
 *   - custName - the customer name
 *   - email - the email value
 *   - registrationDate - an instant value when the item was added to the table. These values
 *                        need to be in the form of `YYYY-MM-DDTHH:mm:ssZ`, such as 2022-07-11T00:00:00Z
 *
 * Also, ensure that you have set up your development environment, including your credentials.
 *
 * For information, see this documentation topic:
 *
 * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
 */

public class EnhancedGetItem {
    public static void main(String[] args) {
        Region region = Region.US_EAST_1;
        DynamoDbClient ddb = DynamoDbClient.builder()
                .region(region)
                .build();

        DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
                .dynamoDbClient(ddb)
                .build();

        getItem(enhancedClient);
        ddb.close();
    }

    public static String getItem(DynamoDbEnhancedClient enhancedClient) {
        Customer result = null;
        try {
            DynamoDbTable<Customer> 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();
    }
}