Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Utilisation de DAX avec le kit SDK AWS pour Java 1.x
<a name="DAX.client.java-sdk-v1"></a>

Pour exécuter l’exemple Java pour Amazon DynamoDB Accelerator (DAX) sur votre instance Amazon EC2, procédez comme suit.

**Note**  
Ces instructions s’appliquent aux applications utilisant le kit SDK AWS pour Java 1.x. Pour les applications utilisant le kit SDK AWS pour Java 2.x, consultez [Java et DAX](DAX.client.run-application-java.md).

**Pour exécuter l’exemple Java pour DAX**

1. Installez le kit de développement Java (JDK).

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

1. Téléchargez le AWS SDK pour Java (fichier `.zip`) et extrayez-le.

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

1. Téléchargez la version la plus récente du client Java DAX (fichier `.jar`).

   ```
   wget http://dax-sdk.s3-website-us-west-2.amazonaws.com/java/DaxJavaClient-latest.jar
   ```
**Note**  
Le client pour le kit SDK pour Java DAX est disponible sur Apache Maven. Pour plus d’informations, consultez [Utilisation du client en tant que dépendance Apache Maven](#DAXClient.Maven).

1. Définissez votre variable `CLASSPATH`. Dans l’exemple, remplacez `sdkVersion` par le numéro de version réel d’AWS SDK pour Java, par exemple, `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. Téléchargez le code source de l’exemple de programme (fichier `.zip`).

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

   Une fois le téléchargement terminé, extrayez les fichiers source.

   ```
   unzip TryDax.zip
   ```

1. Accédez au répertoire de code Java et compilez le code comme suit.

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

1. Exécutez le programme.

   ```
   java TryDax
   ```

   Vous devez visualiser des résultats similaires à ce qui suit.

   ```
   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.
   ```

   Notez les informations de durée, soit le nombre de millisecondes requis pour les tests `GetItem`, `Query` et `Scan`.

1. A l’étape précédente, vous avez exécuté le programme par rapport au point de terminaison DynamoDB. À présent, réexécutez le programme, mais cette fois, les opérations `GetItem`, `Query` et `Scan` sont traitées par votre cluster DAX.

   Pour déterminer le point de terminaison de votre cluster DAX, choisissez l’une des options suivantes :
   + **Utilisation de la console DynamoDB** – Choisissez votre cluster DAX. Le point de terminaison du cluster s’affiche dans la console, comme dans l’exemple suivant.

     ```
     dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
     ```
   + **Utilisation de l’AWS CLI** – Entrez la commande suivante.

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

     Le point de terminaison du cluster apparaît dans la sortie, comme dans l’exemple suivant.

     ```
     {
         "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"
     }
     ```

   À présent, réexécutez le programme, mais cette fois, spécifiez le point de terminaison du cluster en tant que paramètre de ligne de commande.

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

   Observez le reste de la sortie et notez les informations de durée. Les délais écoulés pour `GetItem`, `Query` et `Scan` devraient être sensiblement inférieurs avec DAX qu’avec DynamoDB.

Pour plus d’informations sur ce programme, consultez les sections suivantes :
+ [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)

## Utilisation du client en tant que dépendance Apache Maven
<a name="DAXClient.Maven"></a>

Suivez la procédure pour utiliser le client pour le kit SDK DAX pour Java dans votre application comme dépendance.

**Pour utiliser le client comme dépendance Maven**

1. Téléchargez et installez Apache Maven. Pour plus d’informations, consultez [Downloading Apache Maven](https://maven.apache.org/download.cgi) et [Installing Apache Maven](https://maven.apache.org/install.html).

1. Ajoutez la dépendance de client Maven au fichier POM (Project Object Model) de votre application. Dans l’exemple, remplacez `x.x.x.x` par le numéro de version réel du client, par exemple : `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>

Le fichier `TryDax.java` contient la méthode `main`. Si vous exécutez le programme sans paramètre de ligne de commande, il crée un client Amazon DynamoDB et l’utilise pour toutes les opérations d’API. Si vous spécifiez un point de terminaison de cluster DynamoDB Accelerator (DAX) sur la ligne de commande, le programme crée également un client DAX et l’utilise pour les opérations `GetItem`, `Query` et `Scan`.

Vous pouvez modifier le programme de plusieurs façons :
+ Utilisez le client DAX plutôt que le client DynamoDB. Pour plus d’informations, consultez [Java et DAX](DAX.client.run-application-java.md).
+ Attribuez un nom différent à la table de test.
+ Modifiez le nombre d’éléments écrits en modifiant les paramètres `helper.writeData`. Le deuxième paramètre correspond au nombre de clés de partition et le troisième au nombre de clés de tri. Par défaut, le programme utilise 1–10 pour les valeurs de clé de partition, et 1–10 pour les valeurs de clé de tri, pour un total de 100 éléments écrits dans la table. Pour plus d’informations, consultez [TryDaxHelper.java](DAX.client.run-application-java.TryDaxHelper.md).
+ Modifiez le nombre de tests `GetItem`, `Query` et `Scan`, puis modifiez leurs paramètres.
+ Mettez en commentaire les lignes contenant `helper.createTable` et `helper.deleteTable` (si vous ne voulez pas créer et supprimer la table chaque fois que vous exécutez le programme).

**Note**  
Pour exécuter ce programme, vous pouvez configurer Maven afin d’utiliser le kit SDK DAX pour Java et l’AWS SDK pour Java en tant que dépendances. Pour plus d’informations, consultez [Utilisation du client en tant que dépendance Apache Maven](DAX.client.java-sdk-v1.md#DAXClient.Maven).   
Sinon, vous pouvez télécharger et inclure le client Java DAX et l’AWS SDK pour Java dans votre chemin de classe. Consultez [Java et DAX](DAX.client.run-application-java.md) pour obtenir un exemple de configuration de votre variable `CLASSPATH`.

```
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>

Le fichier `TryDaxHelper.java` contient des méthodes d’utilitaire.

Les méthodes `getDynamoDBClient` et `getDaxClient` fournissent des clients Amazon DynamoDB et DynamoDB Accelerator (DAX). Pour les opérations de plan de contrôle (`CreateTable`, `DeleteTable`) et les opérations d’écriture, le programme utilise le client DynamoDB. Si vous spécifiez un point de terminaison de cluster DAX, le programme principal crée un client DAX pour effectuer les opérations de lecture (`GetItem`, `Query`, `Scan`).

Les autres méthodes `TryDaxHelper` (`createTable`, `writeData`, `deleteTable`) sont destinées à la configuration et à la destruction de la table DynamoDB et de ses données.

Vous pouvez modifier le programme de plusieurs façons :
+ Utilisez d’autres paramètres de débit alloué pour la table.
+ Modifiez la taille de chaque élément écrit (voir la variable `stringSize` de la méthode `writeData`).
+ Modifiez le nombre de tests `GetItem`, `Query` et `Scan`, ainsi que leurs paramètres.
+ Mettez en commentaire les lignes contenant `helper.CreateTable` et `helper.DeleteTable` (si vous ne voulez pas créer et supprimer la table chaque fois que vous exécutez le programme).

**Note**  
 Pour exécuter ce programme, vous pouvez configurer Maven afin d’utiliser le kit SDK DAX pour Java et l’AWS SDK pour Java en tant que dépendances. Pour plus d’informations, consultez [Utilisation du client en tant que dépendance Apache Maven](DAX.client.java-sdk-v1.md#DAXClient.Maven).   
Sinon, vous pouvez télécharger et inclure le client Java DAX et l’AWS SDK pour Java dans votre chemin de classe. Consultez [Java et DAX](DAX.client.run-application-java.md) pour obtenir un exemple de configuration de votre variable `CLASSPATH`.

```
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>

Le fichier `TryDaxTests.java` contient des méthodes qui effectuent des opérations de lecture sur une table de test dans Amazon DynamoDB. Ces méthodes n’étant pas concernées par le mode d’accès aux données (à l’aide du client DynamoDB, ou du client DAX), il n’est pas nécessaire de modifier la logique d’application.

Vous pouvez modifier le programme de plusieurs façons :
+ Modifiez la méthode `queryTest` afin qu’elle utilise une autre valeur pour `KeyConditionExpression`.
+ Ajoutez un paramètre `ScanFilter` à la méthode `scanTest` de sorte que seule une partie des éléments vous soient retournés.

**Note**  
 Pour exécuter ce programme, vous pouvez configurer Maven afin d’utiliser le kit SDK DAX pour Java et l’AWS SDK pour Java en tant que dépendances. Pour plus d’informations, consultez [Utilisation du client en tant que dépendance Apache Maven](DAX.client.java-sdk-v1.md#DAXClient.Maven).   
Sinon, vous pouvez télécharger et inclure le client Java DAX et l’AWS SDK pour Java dans votre chemin de classe. Consultez [Java et DAX](DAX.client.run-application-java.md) pour obtenir un exemple de configuration de votre variable `CLASSPATH`.

```
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));
    }
}
```