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.

# Verwenden von DAX mit AWS SDK for Java 1.x
<a name="DAX.client.java-sdk-v1"></a>

Um das Java-Beispiel für Amazon DynamoDB Accelerator (DAX) auf der Amazon-EC2-Instance auszuführen, gehen Sie wie folgt vor.

**Anmerkung**  
Diese Anweisungen gelten für Anwendungen, die AWS SDK for Java 1.x verwenden. Für Anwendungen, die AWS SDK for Java 2.x verwenden, siehe [Java und DAX](DAX.client.run-application-java.md).

**So führen Sie das Java-Beispiel für DAX aus**

1. Installieren des Java Development Kits (JDK).

   ```
   sudo yum install -y java-devel
   ```

1. Laden Sie AWS SDK für Java (`.zip`-Datei) herunter und extrahieren Sie die Datei.

   ```
   wget http://sdk-for-java.amazonwebservices.com/latest/aws-java-sdk.zip
   
   unzip aws-java-sdk.zip
   ```

1. Laden Sie die neueste Version des DAX-Java-Clients (`.jar`-Datei) herunter:

   ```
   wget http://dax-sdk.s3-website-us-west-2.amazonaws.com/java/DaxJavaClient-latest.jar
   ```
**Anmerkung**  
Der Client für das DAX SDK for Java ist auf Apache Maven verfügbar. Weitere Informationen finden Sie unter [Verwenden eines Clients als Apache Maven-Abhängigkeit](#DAXClient.Maven).

1. Legen Sie Ihre `CLASSPATH`-Variable fest. Ersetzen Sie in diesem Beispiel `sdkVersion` durch die tatsächliche Versionsnummer von AWS SDK für Java, zum Beispiel `1.11.112`.

   ```
   export SDKVERSION=sdkVersion
   
   export CLASSPATH=$(pwd)/TryDax/java:$(pwd)/DaxJavaClient-latest.jar:$(pwd)/aws-java-sdk-$SDKVERSION/lib/aws-java-sdk-$SDKVERSION.jar:$(pwd)/aws-java-sdk-$SDKVERSION/third-party/lib/*
   ```

1. Downloaden Sie den Quellcode des Beispielprogramms (`.zip`-Datei):

   ```
   wget http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/samples/TryDax.zip
   ```

   Wenn der Download abgeschlossen ist, extrahieren Sie die Quelldateien.

   ```
   unzip TryDax.zip
   ```

1. Navigieren Sie zum Java-Code-Verzeichnis und kompilieren Sie den Code wie folgt.

   ```
   cd TryDax/java/
   javac TryDax*.java
   ```

1. Führen Sie das Programm aus.

   ```
   java TryDax
   ```

   Die Ausgabe sollte in etwa wie folgt aussehen:

   ```
   Creating a DynamoDB client
   
   Attempting to create table; please wait...
   Successfully created table.  Table status: ACTIVE
   Writing data to the table...
   Writing 10 items for partition key: 1
   Writing 10 items for partition key: 2
   Writing 10 items for partition key: 3
   Writing 10 items for partition key: 4
   Writing 10 items for partition key: 5
   Writing 10 items for partition key: 6
   Writing 10 items for partition key: 7
   Writing 10 items for partition key: 8
   Writing 10 items for partition key: 9
   Writing 10 items for partition key: 10
   
   Running GetItem, Scan, and Query tests...
   First iteration of each test will result in cache misses
   Next iterations are cache hits
   
   GetItem test - partition key 1 and sort keys 1-10
   	Total time: 136.681 ms - Avg time: 13.668 ms
   	Total time: 122.632 ms - Avg time: 12.263 ms
   	Total time: 167.762 ms - Avg time: 16.776 ms
   	Total time: 108.130 ms - Avg time: 10.813 ms
   	Total time: 137.890 ms - Avg time: 13.789 ms
   Query test - partition key 5 and sort keys between 2 and 9
   	Total time: 13.560 ms - Avg time: 2.712 ms
   	Total time: 11.339 ms - Avg time: 2.268 ms
   	Total time: 7.809 ms - Avg time: 1.562 ms
   	Total time: 10.736 ms - Avg time: 2.147 ms
   	Total time: 12.122 ms - Avg time: 2.424 ms
   Scan test - all items in the table
   	Total time: 58.952 ms - Avg time: 11.790 ms
   	Total time: 25.507 ms - Avg time: 5.101 ms
   	Total time: 37.660 ms - Avg time: 7.532 ms
   	Total time: 26.781 ms - Avg time: 5.356 ms
   	Total time: 46.076 ms - Avg time: 9.215 ms
   
   Attempting to delete table; please wait...
   Successfully deleted table.
   ```

   Beachten Sie die Zeitinformationen – die Anzahl der benötigten Millisekunden für den `GetItem`-, `Query`- und `Scan`-Test.

1. Im vorherigen Schritt führten Sie das Programm über den DynamoDB-Endpunkt aus. Führen Sie das Programm jetzt erneut aus. Dieses Mal werden die `GetItem`-, `Query`- und `Scan`-Operationen jedoch vom DAX-Cluster verarbeitet.

   Um den Endpunkt für Ihren DAX-Cluster zu bestimmen, wählen Sie einen der folgenden Schritte aus:
   + **Using the DynamoDB console** (Verwenden der DynamoDB-Konsole) — Wählen Sie Ihren DAX-Cluster aus. Der Cluster-Endpunkt wird auf der Konsole angezeigt, wie im folgenden Beispiel gezeigt.

     ```
     dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
     ```
   + **Verwenden von AWS CLI** – Geben Sie den folgenden Befehl ein.

     ```
     aws dax describe-clusters --query "Clusters[*].ClusterDiscoveryEndpoint"
     ```

     Der Cluster-Endpunkt wird in der Ausgabe angezeigt, wie im folgenden Beispiel gezeigt.

     ```
     {
         "Address": "my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com",
         "Port": 8111,
         "URL": "dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com"
     }
     ```

   Führen Sie jetzt das Programm erneut aus. Geben Sie dieses Mal jedoch den Cluster-Endpunkt als Befehlszeilenparameter an.

   ```
   java TryDax dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
   ```

   Sehen Sie sich den Rest der Ausgabe an und notieren Sie die Zeitinformationen. Die verstrichene Zeit sollte für `GetItem`, `Query` und `Scan` mit DAX deutlich kürzer sein als mit DynamoDB.

Weitere Informationen zu diesem Programm finden Sie in folgenden Abschnitten:
+ [TryDax.java](DAX.client.run-application-java.TryDax.md)
+ [TryDaxHelper.java](DAX.client.run-application-java.TryDaxHelper.md)
+ [TryDaxTests.java](DAX.client.run-application-java.TryDaxTests.md)

## Verwenden eines Clients als Apache Maven-Abhängigkeit
<a name="DAXClient.Maven"></a>

Führen Sie die folgenden Schritte aus, um den Client für das DAX SDK for Java als Abhängigkeit in Ihrer Anwendung zu verwenden.

**So verwenden Sie den Client als Maven-Abhängigkeit**

1. Laden Sie Apache Maven herunter und installieren Sie es. Weitere Informationen finden Sie unter [Downloading Apache Maven](https://maven.apache.org/download.cgi) und [Installing Apache Maven](https://maven.apache.org/install.html).

1. Fügen Sie die Client-Maven-Abhängigkeit der POM-Datei (Project Object Model) Ihrer Anwendung hinzu. Ersetzen Sie in diesem Beispiel `x.x.x.x` durch die tatsächliche Versionsnummer des Clients (z. B. `1.0.200704.0`).

   ```
   <!--Dependency:-->
   <dependencies>
       <dependency>
        <groupId>com.amazonaws</groupId>
        <artifactId>amazon-dax-client</artifactId>
        <version>x.x.x.x</version>
       </dependency>
   </dependencies>
   ```

# TryDax.java
<a name="DAX.client.run-application-java.TryDax"></a>

Die `TryDax.java`-Datei enthält die `main`-Methode. Wenn Sie das Programm ohne Befehlszeilenparameter ausführen, erstellt es einen Amazon-DynamoDB-Client und verwendet diesen für alle API-Operationen. Wenn Sie einen DynamoDB-Accelerator-(DAX)-Cluster-Endpunkt in der Befehlszeile angeben, erstellt das Programm auch einen DAX-Client und verwendet diesen für `GetItem`-, `Query`- und `Scan`-Operationen.

Sie können das Programm auf verschiedene Arten ändern.
+ Verwenden Sie den DAX-Client anstelle des DynamoDB-Clients. Weitere Informationen finden Sie unter [Java und DAX](DAX.client.run-application-java.md).
+ Wählen Sie einen anderen Namen für die Testtabelle aus.
+ Ändern Sie die Anzahl der Elemente, indem Sie die Parameter `helper.writeData` ändern. Der zweite Parameter ist die Anzahl der Partitionsschlüssel und der dritte Parameter ist die Anzahl der Sortierschlüssel. Standardmäßig verwendet das Programm 1-10 für Partitions-Schlüsselwerte und 1-10 für Sortierschlüsselwerte für insgesamt 100 Elemente, die in die Tabelle geschrieben werden. Weitere Informationen finden Sie unter [TryDaxHelper.java](DAX.client.run-application-java.TryDaxHelper.md).
+ Ändern Sie die Anzahl der `GetItem`-, `Query`- und `Scan`-Tests und ändern Sie deren Parameter.
+ Kommentieren Sie die Zeilen, die `helper.createTable` und `helper.deleteTable` beinhalten (wenn Sie die Tabelle nicht bei jeder Nutzung des Programms erstellen und löschen möchten).

**Anmerkung**  
Zur Ausführung dieses Programms können Sie Maven so einrichten, dass der Client für das DAX SDK for Java und AWS SDK für Java als Abhängigkeiten verwendet werden. Weitere Informationen finden Sie unter [Verwenden eines Clients als Apache Maven-Abhängigkeit](DAX.client.java-sdk-v1.md#DAXClient.Maven).   
Sie können den DAX-Java-Client und AWS SDK für Java auch herunterladen und in den Klassenpfad einschließen. Unter [Java und DAX](DAX.client.run-application-java.md) finden Sie ein Beispiel für die Einrichtung Ihrer `CLASSPATH`-Variablen.

```
public class TryDax {

    public static void main(String[] args) throws Exception {

        TryDaxHelper helper = new TryDaxHelper();
        TryDaxTests tests = new TryDaxTests();

        DynamoDB ddbClient = helper.getDynamoDBClient();
        DynamoDB daxClient = null;
        if (args.length >= 1) {
            daxClient = helper.getDaxClient(args[0]);
        }

        String tableName = "TryDaxTable";

        System.out.println("Creating table...");
        helper.createTable(tableName, ddbClient);
        System.out.println("Populating table...");
        helper.writeData(tableName, ddbClient, 10, 10);

        DynamoDB testClient = null;
        if (daxClient != null) {
            testClient = daxClient;
        } else {
            testClient = ddbClient;
        }

        System.out.println("Running GetItem, Scan, and Query tests...");
        System.out.println("First iteration of each test will result in cache misses");
        System.out.println("Next iterations are cache hits\n");

        // GetItem
        tests.getItemTest(tableName, testClient, 1, 10, 5);

        // Query
        tests.queryTest(tableName, testClient, 5, 2, 9, 5);

        // Scan
        tests.scanTest(tableName, testClient, 5);

        helper.deleteTable(tableName, ddbClient);
    }

}
```

# TryDaxHelper.java
<a name="DAX.client.run-application-java.TryDaxHelper"></a>

Die `TryDaxHelper.java`-Datei enthält Dienstprogrammmethoden.

Die `getDynamoDBClient`- und `getDaxClient`-Methoden stellen Amazon-DynamoDB- und DynamoDB-Accelerator-(DAX)-Clients bereit. Für Vorgänge der Steuerebene (`CreateTable`, `DeleteTable`) und Schreibvorgänge verwendet das Programm den DynamoDB-Client. Wenn Sie einen DAX-Cluster-Endpunkt angeben, erstellt das Hauptprogramm einen DAX-Client für das Durchführen von Schreibvorgänge (`GetItem`, `Query`, `Scan`).

Die anderen `TryDaxHelper`-Methoden (`createTable`, `writeData`, `deleteTable`) dienen dem Einrichten und Entfernen der DynamoDB-Tabelle und der enthaltenen Daten.

Sie können das Programm auf verschiedene Arten ändern.
+ Verwenden Sie verschiedene bereitgestellte Durchsatzeinstellungen für die Tabelle.
+ Ändern Sie die Größe jedes geschriebenen Elements (siehe `stringSize`-Variablen in der `writeData`-Methode).
+ Ändern Sie die Anzahl der `GetItem`-, `Query`- und `Scan`-Tests und deren Parameter.
+ Kommentieren Sie die Zeilen, die `helper.CreateTable` und `helper.DeleteTable` beinhalten (wenn Sie die Tabelle nicht bei jeder Nutzung des Programms erstellen und löschen möchten).

**Anmerkung**  
 Zur Ausführung dieses Programms können Sie Maven so einrichten, dass der Client für das DAX SDK for Java und AWS SDK für Java als Abhängigkeiten verwendet werden. Weitere Informationen finden Sie unter [Verwenden eines Clients als Apache Maven-Abhängigkeit](DAX.client.java-sdk-v1.md#DAXClient.Maven).   
Sie können den DAX-Java-Client und AWS SDK für Java auch herunterladen und in den Klassenpfad einschließen. Unter [Java und DAX](DAX.client.run-application-java.md) finden Sie ein Beispiel für die Einrichtung Ihrer `CLASSPATH`-Variablen.

```
import com.amazon.dax.client.dynamodbv2.AmazonDaxClientBuilder;
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.model.AttributeDefinition;
import com.amazonaws.services.dynamodbv2.model.KeySchemaElement;
import com.amazonaws.services.dynamodbv2.model.KeyType;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;
import com.amazonaws.services.dynamodbv2.model.ScalarAttributeType;
import com.amazonaws.util.EC2MetadataUtils;

public class TryDaxHelper {

    private static final String region = EC2MetadataUtils.getEC2InstanceRegion();

    DynamoDB getDynamoDBClient() {
        System.out.println("Creating a DynamoDB client");
        AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard()
                .withRegion(region)
                .build();
        return new DynamoDB(client);
    }

    DynamoDB getDaxClient(String daxEndpoint) {
        System.out.println("Creating a DAX client with cluster endpoint " + daxEndpoint);
        AmazonDaxClientBuilder daxClientBuilder = AmazonDaxClientBuilder.standard();
        daxClientBuilder.withRegion(region).withEndpointConfiguration(daxEndpoint);
        AmazonDynamoDB client = daxClientBuilder.build();
        return new DynamoDB(client);
    }

    void createTable(String tableName, DynamoDB client) {
        Table table = client.getTable(tableName);
        try {
            System.out.println("Attempting to create table; please wait...");

            table = client.createTable(tableName,
                    Arrays.asList(
                            new KeySchemaElement("pk", KeyType.HASH), // Partition key
                            new KeySchemaElement("sk", KeyType.RANGE)), // Sort key
                    Arrays.asList(
                            new AttributeDefinition("pk", ScalarAttributeType.N),
                            new AttributeDefinition("sk", ScalarAttributeType.N)),
                    new ProvisionedThroughput(10L, 10L));
            table.waitForActive();
            System.out.println("Successfully created table.  Table status: " +
                    table.getDescription().getTableStatus());

        } catch (Exception e) {
            System.err.println("Unable to create table: ");
            e.printStackTrace();
        }
    }

    void writeData(String tableName, DynamoDB client, int pkmax, int skmax) {
        Table table = client.getTable(tableName);
        System.out.println("Writing data to the table...");

        int stringSize = 1000;
        StringBuilder sb = new StringBuilder(stringSize);
        for (int i = 0; i < stringSize; i++) {
            sb.append('X');
        }
        String someData = sb.toString();

        try {
            for (Integer ipk = 1; ipk <= pkmax; ipk++) {
                System.out.println(("Writing " + skmax + " items for partition key: " + ipk));
                for (Integer isk = 1; isk <= skmax; isk++) {
                    table.putItem(new Item()
                            .withPrimaryKey("pk", ipk, "sk", isk)
                            .withString("someData", someData));
                }
            }
        } catch (Exception e) {
            System.err.println("Unable to write item:");
            e.printStackTrace();
        }
    }

    void deleteTable(String tableName, DynamoDB client) {
        Table table = client.getTable(tableName);
        try {
            System.out.println("\nAttempting to delete table; please wait...");
            table.delete();
            table.waitForDelete();
            System.out.println("Successfully deleted table.");

        } catch (Exception e) {
            System.err.println("Unable to delete table: ");
            e.printStackTrace();
        }
    }

}
```

# TryDaxTests.java
<a name="DAX.client.run-application-java.TryDaxTests"></a>

Die `TryDaxTests.java`-Datei enthält Methoden, die Leseoperationen über eine Testtabelle in Amazon DynamoDB durchführen. Diese Methoden berücksichtigen nicht, wie sie auf die Daten zugreifen (entweder mithilfe des DynamoDB-Clients oder des DAX-Clients). Daher ist es nicht erforderlich, die Anwendungslogik zu ändern.

Sie können das Programm auf verschiedene Arten ändern.
+ Ändern Sie die `queryTest`-Methode, damit sie einen anderen `KeyConditionExpression` verwendet.
+ Fügen Sie der `scanTest`-Methode einen `ScanFilter` hinzu, damit nur einige der Elemente an Sie zurückgegeben werden.

**Anmerkung**  
 Zur Ausführung dieses Programms können Sie Maven so einrichten, dass der Client für das DAX SDK for Java und AWS SDK für Java als Abhängigkeiten verwendet werden. Weitere Informationen finden Sie unter [Verwenden eines Clients als Apache Maven-Abhängigkeit](DAX.client.java-sdk-v1.md#DAXClient.Maven).   
Sie können den DAX-Java-Client und AWS SDK für Java auch herunterladen und in den Klassenpfad einschließen. Unter [Java und DAX](DAX.client.run-application-java.md) finden Sie ein Beispiel für die Einrichtung Ihrer `CLASSPATH`-Variablen.

```
import java.util.Iterator;

import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.ItemCollection;
import com.amazonaws.services.dynamodbv2.document.QueryOutcome;
import com.amazonaws.services.dynamodbv2.document.ScanOutcome;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.spec.QuerySpec;

public class TryDaxTests {

    void getItemTest(String tableName, DynamoDB client, int pk, int sk, int iterations) {
        long startTime, endTime;
        System.out.println("GetItem test - partition key " + pk + " and sort keys 1-" + sk);
        Table table = client.getTable(tableName);

        for (int i = 0; i < iterations; i++) {
            startTime = System.nanoTime();
            try {
                for (Integer ipk = 1; ipk <= pk; ipk++) {
                    for (Integer isk = 1; isk <= sk; isk++) {
                        table.getItem("pk", ipk, "sk", isk);
                    }
                }
            } catch (Exception e) {
                System.err.println("Unable to get item:");
                e.printStackTrace();
            }
            endTime = System.nanoTime();
            printTime(startTime, endTime, pk * sk);
        }
    }

    void queryTest(String tableName, DynamoDB client, int pk, int sk1, int sk2, int iterations) {
        long startTime, endTime;
        System.out.println("Query test - partition key " + pk + " and sort keys between " + sk1 + " and " + sk2);
        Table table = client.getTable(tableName);

        HashMap<String, Object> valueMap = new HashMap<String, Object>();
        valueMap.put(":pkval", pk);
        valueMap.put(":skval1", sk1);
        valueMap.put(":skval2", sk2);

        QuerySpec spec = new QuerySpec()
                .withKeyConditionExpression("pk = :pkval and sk between :skval1 and :skval2")
                .withValueMap(valueMap);

        for (int i = 0; i < iterations; i++) {
            startTime = System.nanoTime();
            ItemCollection<QueryOutcome> items = table.query(spec);

            try {
                Iterator<Item> iter = items.iterator();
                while (iter.hasNext()) {
                    iter.next();
                }
            } catch (Exception e) {
                System.err.println("Unable to query table:");
                e.printStackTrace();
            }
            endTime = System.nanoTime();
            printTime(startTime, endTime, iterations);
        }
    }

    void scanTest(String tableName, DynamoDB client, int iterations) {
        long startTime, endTime;
        System.out.println("Scan test - all items in the table");
        Table table = client.getTable(tableName);

        for (int i = 0; i < iterations; i++) {
            startTime = System.nanoTime();
            ItemCollection<ScanOutcome> items = table.scan();
            try {

                Iterator<Item> iter = items.iterator();
                while (iter.hasNext()) {
                    iter.next();
                }
            } catch (Exception e) {
                System.err.println("Unable to scan table:");
                e.printStackTrace();
            }
            endTime = System.nanoTime();
            printTime(startTime, endTime, iterations);
        }
    }

    public void printTime(long startTime, long endTime, int iterations) {
        System.out.format("\tTotal time: %.3f ms - ", (endTime - startTime) / (1000000.0));
        System.out.format("Avg time: %.3f ms\n", (endTime - startTime) / (iterations * 1000000.0));
    }
}
```