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

Siga este procedimiento para ejecutar el ejemplo de Java para Amazon DynamoDB Accelerator (DAX) en su instancia de Amazon EC2.

**nota**  
Estas instrucciones son para aplicaciones que utilizan SDK de AWS para Java 1.x. Para aplicaciones que utilizan SDK de AWS para Java 2.x, consulte [Java y DAX](DAX.client.run-application-java.md).

**Para ejecutar el ejemplo de Java para DAX**

1. Instale el kit de desarrollo de Java (JDK).

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

1. Descargue el archivo del AWS SDK para Java (archivo `.zip`) y, a continuación, extráigalo.

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

1. Descargue en la última versión del cliente Java de DAX; (archivo `.jar`):

   ```
   wget http://dax-sdk.s3-website-us-west-2.amazonaws.com/java/DaxJavaClient-latest.jar
   ```
**nota**  
El cliente del SDK de DAX para Java está disponible en Apache Maven. Para obtener más información, consulte [Uso del cliente como dependencia de Apache Maven](#DAXClient.Maven).

1. Establezca la variable `CLASSPATH`. En este ejemplo, sustituya `sdkVersion` por el número de versión real de AWS SDK para Java, (por ejemplo: `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. Descargue el código fuente del programa de ejemplo (archivo `.zip`).

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

   Cuando haya terminado la descarga, extraiga los archivos de código fuente.

   ```
   unzip TryDax.zip
   ```

1. Navegue hasta el directorio de código Java y compile el código de la siguiente manera.

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

1. Ejecute el programa.

   ```
   java TryDax
   ```

   Debería ver un resultado similar a este.

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

   Tome nota de la información de tiempo; es decir, del número de milisegundos necesarios para realizar las pruebas de `GetItem`, `Query` y `Scan`.

1. En el paso anterior, ha ejecutado el programa en el punto de enlace de DynamoDB. Ahora, ejecute el programa de nuevo, pero, esta vez, las operaciones `GetItem`, `Query` y `Scan` se procesan en el clúster de DAX.

   Para determinar el punto de enlace del clúster de DAX, elija una de las opciones siguientes:
   + **En la consola de DynamoDB**: elija su clúster de DAX. El punto de enlace del clúster se muestra en la consola, como en el siguiente ejemplo.

     ```
     dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
     ```
   + **En la AWS CLI**: ingrese el siguiente comando.

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

     El punto de enlace del clúster se muestra en el resultado, como en el siguiente ejemplo.

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

   Ahora, vuelva a ejecutar el programa, pero, esta vez, especifique el punto de enlace del clúster como parámetro en la línea de comandos.

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

   Fíjese en el resto del resultado y tome nota de la información sobre tiempos. Los tiempos transcurridos para las operaciones `GetItem`, `Query` y `Scan` deberían ser significativamente menores con DAX que con DynamoDB.

Para obtener más información sobre este programa, consulte las siguientes secciones:
+ [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)

## Uso del cliente como dependencia de Apache Maven
<a name="DAXClient.Maven"></a>

Siga estos pasos para utilizar el cliente para el SDK de DAX para Java en su aplicación como una dependencia.

**Para usar el cliente como una dependencia de Maven**

1. Descargue e instale Apache Maven. Para obtener más información, consulte [Downloading Apache Maven](https://maven.apache.org/download.cgi) e [Installing Apache Maven](https://maven.apache.org/install.html).

1. Agregue la dependencia de Maven del cliente al archivo POM (Project Object Model) de la aplicación. En este ejemplo, sustituya `x.x.x.x` por el número de versión real del cliente (por ejemplo: `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>

El archivo `TryDax.java` contiene el método `main`. Si ejecuta el programa sin parámetros de línea de comandos, se crea un cliente de Amazon DynamoDB que se utiliza para todas las operaciones de la API. Si especifica el punto de enlace de un clúster de DynamoDB Accelerator (DAX) en la línea de comandos, el programa crea también un cliente de DAX y lo utiliza para las operaciones `GetItem`, `Query` y `Scan`.

Puede modificar el programa de varias maneras:
+ Utilizar el cliente de DAX en lugar del cliente de DynamoDB. Para obtener más información, consulte [Java y DAX](DAX.client.run-application-java.md).
+ Elegir otro nombre para la tabla de prueba.
+ Cambiar los parámetros de `helper.writeData` para modificar el número de elementos que se escriben. El segundo parámetro es el número de claves de partición y el tercero, el número de claves de ordenación. De forma predeterminada, el programa usa entre 1 y 10 valores de clave de partición y entre 1 y 10 valores de clave de ordenación, lo que equivale a un total de 100 elementos escritos en la tabla. Para obtener más información, consulte [TryDaxHelper.java](DAX.client.run-application-java.TryDaxHelper.md).
+ Modificar el número de pruebas de `GetItem`, `Query` y `Scan`, así como sus parámetros.
+ Marcar como comentarios las líneas que contienen `helper.createTable` y `helper.deleteTable`, sin no desea crear y eliminar la tabla cada vez que ejecute el programa.

**nota**  
Para ejecutar este programa, puede configurar Maven para usar el cliente para el SDK de DAX para Java y AWS SDK para Java como dependencias. Para obtener más información, consulte [Uso del cliente como dependencia de Apache Maven](DAX.client.java-sdk-v1.md#DAXClient.Maven).   
Como alternativa, puede descargar e incluir el cliente Java de DAX y el AWS SDK para Java en su classpath. Consulte [Java y DAX](DAX.client.run-application-java.md) para ver un ejemplo de cómo establecer la 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>

El archivo `TryDaxHelper.java` contiene métodos de utilidad.

Los métodos `getDynamoDBClient` y `getDaxClient` proporcionan clientes de Amazon DynamoDB y DynamoDB Accelerator (DAX). Para las operaciones del plano de control (`CreateTable`, `DeleteTable`) y las operaciones de escritura, el programa utiliza el cliente de DynamoDB. Si especifica el punto de enlace de un clúster de DAX, el programa principal crea un cliente de DAX para llevar a cabo las operaciones de lectura (`GetItem`, `Query`, `Scan`).

Los demás métodos de `TryDaxHelper` (`createTable`, `writeData` y `deleteTable`) se utilizan para configurar y eliminar la tabla de DynamoDB y sus datos.

Puede modificar el programa de varias maneras:
+ Utilizar unos ajustes de desempeño provisionado diferentes para la tabla.
+ Modificar el tamaño de cada elemento escrito (consulte la variable `stringSize` del método `writeData`).
+ Modificar el número de pruebas de `GetItem`, `Query` y `Scan` y sus parámetros.
+ Marcar como comentarios las líneas que contienen `helper.CreateTable` y `helper.DeleteTable`, sin no desea crear y eliminar la tabla cada vez que ejecute el programa.

**nota**  
 Para ejecutar este programa, puede configurar Maven para usar el cliente para el SDK de DAX para Java y AWS SDK para Java como dependencias. Para obtener más información, consulte [Uso del cliente como dependencia de Apache Maven](DAX.client.java-sdk-v1.md#DAXClient.Maven).   
O, puede descargar e incluir el cliente Java de DAX y el AWS SDK para Java en su classpath. Consulte [Java y DAX](DAX.client.run-application-java.md) para ver un ejemplo de cómo establecer la 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>

El archivo `TryDaxTests.java` contiene métodos que llevan a cabo operaciones de lectura en una tabla de prueba en Amazon DynamoDB . Estos métodos no tienen en cuenta cómo acceder a los datos (mediante el cliente de DynamoDB o de DAX), por lo que no es necesario modificar la lógica de la aplicación.

Puede modificar el programa de varias maneras:
+ Modificar el método `queryTest` de modo que use otra expresión `KeyConditionExpression`.
+ Agregar un filtro `ScanFilter` al método `scanTest` para que solamente se devuelvan algunos de los elementos.

**nota**  
 Para ejecutar este programa, puede configurar Maven para usar el cliente para el SDK de DAX para Java y AWS SDK para Java como dependencias. Para obtener más información, consulte [Uso del cliente como dependencia de Apache Maven](DAX.client.java-sdk-v1.md#DAXClient.Maven).   
O, puede descargar e incluir el cliente Java de DAX y el AWS SDK para Java en su classpath. Consulte [Java y DAX](DAX.client.run-application-java.md) para ver un ejemplo de cómo establecer la 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));
    }
}
```