Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Uso di DAX con AWS SDK per Java 1.x
<a name="DAX.client.java-sdk-v1"></a>

Seguire questa procedura per eseguire l'applicazione di esempio Java per Amazon DynamoDB Accelerator (DAX) sull'istanza Amazon EC2.

**Nota**  
Queste istruzioni sono per le applicazioni che utilizzano AWS SDK per Java 1.x. Per le applicazioni che utilizzano AWS SDK for Java 2.x, vedere [Java e DAX](DAX.client.run-application-java.md).

**Come eseguire l'applicazione di esempio Java per DAX**

1. Installa Java Development Kit (JDK).

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

1. Scarica AWS SDK per Java (file `.zip`) ed estrailo.

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

1. Scaricare la versione più recente del client Java DAX (file `.jar`).

   ```
   wget http://dax-sdk.s3-website-us-west-2.amazonaws.com/java/DaxJavaClient-latest.jar
   ```
**Nota**  
Il client per l'SDK DAX per Java è disponibile su Apache Maven. Per ulteriori informazioni, consulta [Utilizzo del client come una dipendenza Apache Maven](#DAXClient.Maven).

1. Imposta la variabile `CLASSPATH`. In questo esempio, sostituire `sdkVersion` con il numero effettivo della versione di AWS SDK per Java (ad esempio, `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. Scarica il codice sorgente del programma di esempio (file `.zip`).

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

   Al termine del download, estrai i file di origine.

   ```
   unzip TryDax.zip
   ```

1. Passare alla directory del codice Java e compilare il codice come riportato di seguito.

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

1. Esegui il programma.

   ```
   java TryDax
   ```

   Verrà visualizzato un output simile al seguente.

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

   Prendi nota delle informazioni sui tempi: il numero di millisecondi richiesto per i test `GetItem`, `Query` e `Scan`.

1. Nella fase precedente, il programma è stato eseguito sull'endpoint DynamoDB. Ora eseguire nuovamente il programma, ma questa volta le operazioni `GetItem`, `Query` e `Scan` vengono elaborate dal cluster DAX.

   Per determinare l'endpoint per il cluster DAX, scegli una delle seguenti opzioni:
   + **Utilizzo della console DynamoDB**: scegli il cluster DAX. L'endpoint del cluster viene visualizzato nella console, come nell'esempio seguente.

     ```
     dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
     ```
   + **Utilizzo della AWS CLI**: immettere il comando riportato di seguito.

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

     L'endpoint del cluster viene visualizzato nell'output, come nell'esempio seguente.

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

   Ora esegui di nuovo il programma, ma questa volta specifica l'endpoint del cluster come parametro della riga di comando.

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

   Guarda il resto dell'output e prendi nota delle informazioni sui tempi. I tempi trascorsi per `GetItem`, `Query` e `Scan` devono essere significativamente più bassi con DAX che con DynamoDB.

Per ulteriori informazioni sul programma, consulta le seguenti sezioni:
+ [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)

## Utilizzo del client come una dipendenza Apache Maven
<a name="DAXClient.Maven"></a>

Segui queste fasi per utilizzare il client per l'SDK DAX per Java nella tua applicazione come una dipendenza:

**Per utilizzare il client come dipendenza Maven**

1. Scarica e installa Apache Maven. Per ulteriori informazioni, consulta le pagine relative al [download di Apache Maven](https://maven.apache.org/download.cgi) e all'[installazione di Apache Maven](https://maven.apache.org/install.html).

1. Aggiungi la dipendenza Maven client al file POM (Project Object Model) dell'applicazione. In questo esempio, sostituisci `x.x.x.x` con il numero effettivo della versione del client (ad esempio, `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>

Il file `TryDax.java` contiene il metodo `main`. Se si esegue il programma senza parametri della riga di comando, viene creato un client Amazon DynamoDB che viene utilizzato per tutte le operazioni API. Se si specifica un endpoint del cluster DynamoDB Accelerator (DAX) sulla riga di comando, il programma crea anche un client DAX e lo usa per le operazioni `GetItem`, `Query` e `Scan`.

Puoi modificare il programma in diversi modi:
+ Utilizza il client DAX anziché il client DynamoDB. Per ulteriori informazioni, consulta [Java e DAX](DAX.client.run-application-java.md).
+ Scegli un nome diverso per la tabella di test.
+ Modifica il numero di item scritti cambiando i parametri `helper.writeData`. Il secondo parametro è il numero di chiavi di partizione e il terzo parametro è il numero di chiavi di ordinamento. Per impostazione predefinita, il programma utilizza 1-10 per i valori delle chiavi di partizione e 1-10 per i valori delle chiavi di ordinamento, per un totale di 100 elementi scritti nella tabella. Per ulteriori informazioni, consulta [TryDaxHelper.java](DAX.client.run-application-java.TryDaxHelper.md).
+ Modifica il numero dei test `GetItem`, `Query` e `Scan` e modifica i relativi parametri.
+ Imposta come commento le righe contenenti `helper.createTable` e `helper.deleteTable` (se non vuoi creare ed eliminare la tabella ogni volta che esegui il programma).

**Nota**  
Per eseguire questo programma, è possibile configurare Maven in modo che usi il client per l'SDK per Java DAX e AWS SDK per Java come dipendenze. Per ulteriori informazioni, consulta [Utilizzo del client come una dipendenza Apache Maven](DAX.client.java-sdk-v1.md#DAXClient.Maven).   
In alternativa, è possibile scaricare e includere sia il client Java DAX che AWS SDK per Java nella classpath. Consulta [Java e DAX](DAX.client.run-application-java.md) per un esempio dell'impostazione della variabile `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>

Il file `TryDaxHelper.java` contiene i metodi di utilità.

I metodi `getDynamoDBClient` e `getDaxClient` forniscono i client Amazon DynamoDB e DynamoDB Accelerator (DAX). Per le operazioni del piano di controllo (`CreateTable`, `DeleteTable`) e le operazioni di scrittura, il programma usa il client DynamoDB. Se si specifica un endpoint del cluster DAX, il programma principale crea un client DAX per l'esecuzione delle operazioni di lettura (`GetItem`, `Query`, `Scan`).

Gli altri metodi `TryDaxHelper` (`createTable`, `writeData`, `deleteTable`) sono per la configurazione e la distruzione della tabella DynamoDB e dei relativi dati.

Puoi modificare il programma in diversi modi:
+ Utilizza per la tabella diverse impostazioni del throughput assegnato.
+ Modifica la dimensione di ogni item scritto (vedi la variabile `stringSize` nel metodo `writeData`).
+ Modifica il numero dei test `GetItem`, `Query` e `Scan` e i relativi parametri.
+ Imposta come commento le righe contenenti `helper.CreateTable` e `helper.DeleteTable` (se non vuoi creare ed eliminare la tabella ogni volta che esegui il programma).

**Nota**  
 Per eseguire questo programma, è possibile configurare Maven in modo che usi il client per l'SDK per Java DAX e AWS SDK per Java come dipendenze. Per ulteriori informazioni, consulta [Utilizzo del client come una dipendenza Apache Maven](DAX.client.java-sdk-v1.md#DAXClient.Maven).   
Oppure, è possibile scaricare e includere sia il client Java DAX che AWS SDK per Java nella classpath. Consulta [Java e DAX](DAX.client.run-application-java.md) per un esempio dell'impostazione della variabile `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>

Il file `TryDaxTests.java` contiene i metodi che eseguono operazioni di lettura su una tabella di test in Amazon DynamoDB. Questi metodi non riguardano il modo in cui accedono ai dati (utilizzando il client DynamoDB o il client DAX), quindi non è necessario modificare la logica dell'applicazione.

Puoi modificare il programma in diversi modi:
+ Modifica il metodo `queryTest` in modo che utilizzi una differente `KeyConditionExpression`.
+ Aggiungi un `ScanFilter` al metodo `scanTest` in modo che vengano restituite solo alcuni item.

**Nota**  
 Per eseguire questo programma, è possibile configurare Maven in modo che usi il client per l'SDK per Java DAX e AWS SDK per Java come dipendenze. Per ulteriori informazioni, consulta [Utilizzo del client come una dipendenza Apache Maven](DAX.client.java-sdk-v1.md#DAXClient.Maven).   
Oppure, è possibile scaricare e includere sia il client Java DAX che AWS SDK per Java nella classpath. Consulta [Java e DAX](DAX.client.run-application-java.md) per un esempio dell'impostazione della variabile `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));
    }
}
```